Changeset 64406 in webkit


Ignore:
Timestamp:
Jul 30, 2010 10:04:11 PM (14 years ago)
Author:
kinuko@chromium.org
Message:

2010-07-30 Kinuko Yasuda <​kinuko@chromium.org>

Reviewed by Jian Li.

Decouple FileThread from FileStream to support generic file-related async tasks
​https://bugs.webkit.org/show_bug.cgi?id=43135

No new tests as this doesn't change any functionality.

  • html/FileThread.cpp: (WebCore::FileThread::stop): (WebCore::SameInstancePredicate::SameFilePredicate): (WebCore::SameInstancePredicate::operator()): (WebCore::FileThread::unscheduleTasksInternal):
  • html/FileThread.h: (WebCore::FileThread::create): (WebCore::FileThread::Task::instance): (WebCore::FileThread::Task::Task):
  • html/FileThreadTask.h: Changed all templates to take any type as a callee instance. (WebCore::createFileThreadTask):
Location:
trunk/WebCore
Files:
4 edited

Legend:

Unmodified
Added
Removed

  • trunk/WebCore/ChangeLog

    r64402 r64406  
     12010-07-30  Kinuko Yasuda  <kinuko@chromium.org>
     2
     3        Reviewed by Jian Li.
     4
     5        Decouple FileThread from FileStream to support generic file-related async tasks
     6        https://bugs.webkit.org/show_bug.cgi?id=43135
     7
     8        No new tests as this doesn't change any functionality.
     9
     10        * html/FileThread.cpp:
     11        (WebCore::FileThread::stop):
     12        (WebCore::SameInstancePredicate::SameFilePredicate):
     13        (WebCore::SameInstancePredicate::operator()):
     14        (WebCore::FileThread::unscheduleTasksInternal):
     15        * html/FileThread.h:
     16        (WebCore::FileThread::create):
     17        (WebCore::FileThread::Task::instance):
     18        (WebCore::FileThread::Task::Task):
     19        * html/FileThreadTask.h: Changed all templates to take any type as a callee instance.
     20        (WebCore::createFileThreadTask):
     21
    1222010-07-30  Darin Fisher  <darin@chromium.org>
    223

  • trunk/WebCore/html/FileThread.cpp

    r57229 r64406  
    6262void FileThread::stop()
    6363{
    64     return m_queue.kill();
     64    m_queue.kill();
    6565}
    6666
    … …  
    7070}
    7171
    72 class SameFilePredicate {
     72class SameInstancePredicate {
    7373public:
    74     SameFilePredicate(const FileStream* stream) : m_stream(stream) { }
    75     bool operator()(FileThread::Task* task) const { return task->stream() == m_stream; }
     74    SameInstancePredicate(const void* instance) : m_instance(instance) { }
     75    bool operator()(FileThread::Task* task) const { return task->instance() == m_instance; }
    7676private:
    77     const FileStream* m_stream;
     77    const void* m_instance;
    7878};
    7979
    80 void FileThread::unscheduleTasks(const FileStream* stream)
     80void FileThread::unscheduleTasks(const void* instance)
    8181{
    82     SameFilePredicate predicate(stream);
     82    SameInstancePredicate predicate(instance);
    8383    m_queue.removeIf(predicate);
    8484}

  • trunk/WebCore/html/FileThread.h

    r57229 r64406  
    4545class FileThread : public ThreadSafeShared<FileThread> {
    4646public:
    47     static PassRefPtr<FileThread> create() { return adoptRef(new FileThread()); }
     47    static PassRefPtr<FileThread> create()
     48    {
     49        return adoptRef(new FileThread());
     50    }
     51
    4852    ~FileThread();
    4953
    … …  
    5559        virtual ~Task() { }
    5660        virtual void performTask() = 0;
    57         FileStream* stream() const { return m_stream; }
     61        void* instance() const { return m_instance; }
    5862    protected:
    59         Task(FileStream* stream) : m_stream(stream) { }
    60         FileStream* m_stream;
     63        Task(void* instance) : m_instance(instance) { }
     64        void* m_instance;
    6165    };
    6266
    6367    void postTask(PassOwnPtr<Task> task);
    64     void unscheduleTasks(const FileStream*);
     68
     69    void unscheduleTasks(const void* instance);
    6570
    6671private:

  • trunk/WebCore/html/FileThreadTask.h

    r64162 r64406  
    3333
    3434#include "CrossThreadCopier.h"
     35#include "CrossThreadTask.h"
    3536#include "FileThread.h"
    36 #include <memory>
    3737#include <wtf/PassOwnPtr.h>
    3838#include <wtf/PassRefPtr.h>
    39 #include <wtf/TypeTraits.h>
    4039
    4140namespace WebCore {
    4241
    43 // Traits for the Task.
    44 template<typename T> struct FileThreadTaskTraits {
    45     typedef const T& ParamType;
    46 };
    47 
    48 template<typename T> struct FileThreadTaskTraits<T*> {
    49     typedef T* ParamType;
    50 };
    51 
    52 template<typename T> struct FileThreadTaskTraits<PassRefPtr<T> > {
    53     typedef PassRefPtr<T> ParamType;
    54 };
    55 
    56 template<typename T> struct FileThreadTaskTraits<PassOwnPtr<T> > {
    57     typedef PassOwnPtr<T> ParamType;
    58 };
    59 
    60 template<typename R>
     42template<typename R, typename T>
    6143class FileThreadTask0 : public FileThread::Task {
    6244public:
    63     typedef R (FileStream::*Method)();
    64     typedef FileThreadTask0<R> FileThreadTask;
    65 
    66     static PassOwnPtr<FileThreadTask> create(FileStream* stream, Method method)
    67     {
    68         return new FileThreadTask(stream, method);
    69     }
    70 
    71 private:
    72     FileThreadTask0(FileStream* stream, Method method)
    73         : FileThread::Task(stream)
    74         , m_method(method)
    75     {
    76     }
    77 
    78     virtual void performTask()
    79     {
    80         (*stream().*m_method)();
    81     }
    82 
    83 private:
    84     Method m_method;
    85 };
    86 
    87 template<typename R, typename P1, typename MP1>
     45    typedef R (T::*Method)();
     46    typedef FileThreadTask0<R, T> FileThreadTaskImpl;
     47
     48    static PassOwnPtr<FileThreadTaskImpl> create(T* instance, Method method)
     49    {
     50        return new FileThreadTaskImpl(instance, method);
     51    }
     52
     53private:
     54    FileThreadTask0(T* instance, Method method)
     55        : FileThread::Task(instance)
     56        , m_method(method)
     57    {
     58    }
     59
     60    virtual void performTask()
     61    {
     62        (*static_cast<T*>(instance()).*m_method)();
     63    }
     64
     65private:
     66    Method m_method;
     67};
     68
     69template<typename R, typename T, typename P1, typename MP1>
    8870class FileThreadTask1 : public FileThread::Task {
    8971public:
    90     typedef R (FileStream::*Method)(MP1);
    91     typedef FileThreadTask1<R, P1, MP1> FileThreadTask;
    92     typedef typename FileThreadTaskTraits<P1>::ParamType Param1;
    93 
    94     static PassOwnPtr<FileThreadTask> create(FileStream* stream, Method method, Param1 parameter1)
    95     {
    96         return new FileThreadTask(stream, method, parameter1);
    97     }
    98 
    99 private:
    100     FileThreadTask1(FileStream* stream, Method method, Param1 parameter1)
    101         : FileThread::Task(stream)
     72    typedef R (T::*Method)(MP1);
     73    typedef FileThreadTask1<R, T, P1, MP1> FileThreadTaskImpl;
     74    typedef typename CrossThreadTaskTraits<P1>::ParamType Param1;
     75
     76    static PassOwnPtr<FileThreadTaskImpl> create(T* instance, Method method, Param1 parameter1)
     77    {
     78        return new FileThreadTaskImpl(instance, method, parameter1);
     79    }
     80
     81private:
     82    FileThreadTask1(T* instance, Method method, Param1 parameter1)
     83        : FileThread::Task(instance)
    10284        , m_method(method)
    10385        , m_parameter1(parameter1)
    … …  
    10789    virtual void performTask()
    10890    {
    109         (*stream().*m_method)(m_parameter1);
     91        (*static_cast<T*>(instance()).*m_method)(m_parameter1);
    11092    }
    11193
    … …  
    11597};
    11698
    117 template<typename R, typename P1, typename MP1, typename P2, typename MP2>
     99template<typename R, typename T, typename P1, typename MP1, typename P2, typename MP2>
    118100class FileThreadTask2 : public FileThread::Task {
    119101public:
    120     typedef R (FileStream::*Method)(MP1, MP2);
    121     typedef FileThreadTask2<R, P1, MP1, P2, MP2> FileThreadTask;
    122     typedef typename FileThreadTaskTraits<P1>::ParamType Param1;
    123     typedef typename FileThreadTaskTraits<P2>::ParamType Param2;
    124 
    125     static PassOwnPtr<FileThreadTask> create(FileStream* stream, Method method, Param1 parameter1, Param2 parameter2)
    126     {
    127         return new FileThreadTask(stream, method, parameter1, parameter2);
    128     }
    129 
    130 private:
    131     FileThreadTask2(FileStream* stream, Method method, Param1 parameter1, Param2 parameter2)
    132         : FileThread::Task(stream)
     102    typedef R (T::*Method)(MP1, MP2);
     103    typedef FileThreadTask2<R, T, P1, MP1, P2, MP2> FileThreadTaskImpl;
     104    typedef typename CrossThreadTaskTraits<P1>::ParamType Param1;
     105    typedef typename CrossThreadTaskTraits<P2>::ParamType Param2;
     106
     107    static PassOwnPtr<FileThreadTaskImpl> create(T* instance, Method method, Param1 parameter1, Param2 parameter2)
     108    {
     109        return new FileThreadTaskImpl(instance, method, parameter1, parameter2);
     110    }
     111
     112private:
     113    FileThreadTask2(T* instance, Method method, Param1 parameter1, Param2 parameter2)
     114        : FileThread::Task(instance)
    133115        , m_method(method)
    134116        , m_parameter1(parameter1)
    … …  
    139121    virtual void performTask()
    140122    {
    141         (*stream().*m_method)(m_parameter1, m_parameter2);
     123        (*static_cast<T*>(instance()).*m_method)(m_parameter1, m_parameter2);
    142124    }
    143125
    … …  
    148130};
    149131
    150 template<typename R, typename P1, typename MP1, typename P2, typename MP2, typename P3, typename MP3>
     132template<typename R, typename T, typename P1, typename MP1, typename P2, typename MP2, typename P3, typename MP3>
    151133class FileThreadTask3 : public FileThread::Task {
    152134public:
    153     typedef R (FileStream::*Method)(MP1, MP2, MP3);
    154     typedef FileThreadTask3<R, P1, MP1, P2, MP2, P3, MP3> FileThreadTask;
    155     typedef typename FileThreadTaskTraits<P1>::ParamType Param1;
    156     typedef typename FileThreadTaskTraits<P2>::ParamType Param2;
    157     typedef typename FileThreadTaskTraits<P3>::ParamType Param3;
    158 
    159     static PassOwnPtr<FileThreadTask> create(FileStream* stream, Method method, Param1 parameter1, Param2 parameter2, Param3 parameter3)
    160     {
    161         return new FileThreadTask(stream, method, parameter1, parameter2, parameter3);
    162     }
    163 
    164 private:
    165     FileThreadTask3(FileStream* stream, Method method, Param1 parameter1, Param2 parameter2, Param3 parameter3)
    166         : FileThread::Task(stream)
     135    typedef void (T::*Method)(MP1, MP2, MP3);
     136    typedef FileThreadTask3<R, T, P1, MP1, P2, MP2, P3, MP3> FileThreadTaskImpl;
     137    typedef typename CrossThreadTaskTraits<P1>::ParamType Param1;
     138    typedef typename CrossThreadTaskTraits<P2>::ParamType Param2;
     139    typedef typename CrossThreadTaskTraits<P3>::ParamType Param3;
     140
     141    static PassOwnPtr<FileThreadTaskImpl> create(T* instance, Method method, Param1 parameter1, Param2 parameter2, Param3 parameter3)
     142    {
     143        return new FileThreadTaskImpl(instance, method, parameter1, parameter2, parameter3);
     144    }
     145
     146private:
     147    FileThreadTask3(T* instance, Method method, Param1 parameter1, Param2 parameter2, Param3 parameter3)
     148        : FileThread::Task(instance)
    167149        , m_method(method)
    168150        , m_parameter1(parameter1)
    … …  
    174156    virtual void performTask()
    175157    {
    176         (*stream().*m_method)(m_parameter1, m_parameter2, m_parameter3);
     158        (*static_cast<T*>(instance()).*m_method)(m_parameter1, m_parameter2, m_parameter3);
    177159    }
    178160
    … …  
    184166};
    185167
    186 template<typename R>
    187 PassOwnPtr<FileThread::Task> createFileThreadTask(
    188     FileStream* const callee,
    189     R (FileStream::*method)());
    190 
    191 template<typename R>
    192 PassOwnPtr<FileThread::Task> createFileThreadTask(
    193     FileStream* const callee,
    194     R (FileStream::*method)())
    195 {
    196     return FileThreadTask0<R>::create(
     168template<typename R, typename T>
     169PassOwnPtr<FileThread::Task> createFileThreadTask(
     170    T* const callee,
     171    R (T::*method)());
     172
     173template<typename R, typename T>
     174PassOwnPtr<FileThread::Task> createFileThreadTask(
     175    T* const callee,
     176    R (T::*method)())
     177{
     178    return FileThreadTask0<R, T>::create(
    197179        callee,
    198180        method);
    199181}
    200182
    201 template<typename R, typename P1, typename MP1>
    202 PassOwnPtr<FileThread::Task> createFileThreadTask(
    203     FileStream* const callee,
    204     R (FileStream::*method)(MP1),
     183template<typename R, typename T, typename P1, typename MP1>
     184PassOwnPtr<FileThread::Task> createFileThreadTask(
     185    T* const callee,
     186    R (T::*method)(MP1),
    205187    const P1& parameter1)
    206188{
    207     return FileThreadTask1<R, typename CrossThreadCopier<P1>::Type, MP1>::create(
     189    return FileThreadTask1<R, T, typename CrossThreadCopier<P1>::Type, MP1>::create(
    208190        callee,
    209191        method,
    … …  
    211193}
    212194
    213 template<typename R, typename P1, typename MP1, typename P2, typename MP2>
    214 PassOwnPtr<FileThread::Task> createFileThreadTask(
    215     FileStream* const callee,
    216     R (FileStream::*method)(MP1, MP2),
     195template<typename R, typename T, typename P1, typename MP1, typename P2, typename MP2>
     196PassOwnPtr<FileThread::Task> createFileThreadTask(
     197    T* const callee,
     198    R (T::*method)(MP1, MP2),
    217199    const P1& parameter1,
    218200    const P2& parameter2)
    219201{
    220     return FileThreadTask2<R, typename CrossThreadCopier<P1>::Type, MP1, typename CrossThreadCopier<P2>::Type, MP2>::create(
     202    return FileThreadTask2<R, T, typename CrossThreadCopier<P1>::Type, MP1, typename CrossThreadCopier<P2>::Type, MP2>::create(
    221203        callee,
    222204        method,
    … …  
    225207}
    226208
    227 template<typename R, typename P1, typename MP1, typename P2, typename MP2, typename P3, typename MP3>
    228 PassOwnPtr<FileThread::Task> createFileThreadTask(
    229     FileStream* const callee,
    230     R (FileStream::*method)(MP1, MP2, MP3),
     209template<typename R, typename T, typename P1, typename MP1, typename P2, typename MP2, typename P3, typename MP3>
     210PassOwnPtr<FileThread::Task> createFileThreadTask(
     211    T* const callee,
     212    R (T::*method)(MP1, MP2, MP3),
    231213    const P1& parameter1,
    232214    const P2& parameter2,
    233215    const P3& parameter3)
    234216{
    235     return FileThreadTask3<R, typename CrossThreadCopier<P1>::Type, MP1, typename CrossThreadCopier<P2>::Type, MP2, typename CrossThreadCopier<P3>::Type, MP3>::create(
     217    return FileThreadTask3<R, T, typename CrossThreadCopier<P1>::Type, MP1, typename CrossThreadCopier<P2>::Type, MP2, typename CrossThreadCopier<P3>::Type, MP3>::create(
    236218        callee,
    237219        method,
Note: See TracChangeset for help on using the changeset viewer.