Home | History | Annotate | Download | only in filesystem 
      1 /*
      2  * Copyright (C) 2010 Google Inc. All rights reserved.
      3  * Copyright (C) 2013 Samsung Electronics. All rights reserved.
      4  *
      5  * Redistribution and use in source and binary forms, with or without
      6  * modification, are permitted provided that the following conditions are
      7  * met:
      8  *
      9  *     * Redistributions of source code must retain the above copyright
     10  * notice, this list of conditions and the following disclaimer.
     11  *     * Redistributions in binary form must reproduce the above
     12  * copyright notice, this list of conditions and the following disclaimer
     13  * in the documentation and/or other materials provided with the
     14  * distribution.
     15  *     * Neither the name of Google Inc. nor the names of its
     16  * contributors may be used to endorse or promote products derived from
     17  * this software without specific prior written permission.
     18  *
     19  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
     20  * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
     21  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
     22  * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
     23  * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
     24  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
     25  * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
     26  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
     27  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
     28  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
     29  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
     30  */
     31 
     32 #ifndef SyncCallbackHelper_h
     33 #define SyncCallbackHelper_h
     34 
     35 #include "bindings/v8/ExceptionState.h"
     36 #include "core/fileapi/FileError.h"
     37 #include "core/html/VoidCallback.h"
     38 #include "modules/filesystem/DirectoryEntry.h"
     39 #include "modules/filesystem/DirectoryReaderSync.h"
     40 #include "modules/filesystem/EntriesCallback.h"
     41 #include "modules/filesystem/EntryCallback.h"
     42 #include "modules/filesystem/EntrySync.h"
     43 #include "modules/filesystem/ErrorCallback.h"
     44 #include "modules/filesystem/FileEntry.h"
     45 #include "modules/filesystem/FileSystemCallback.h"
     46 #include "modules/filesystem/MetadataCallback.h"
     47 #include "wtf/PassRefPtr.h"
     48 #include "wtf/RefCounted.h"
     49 
     50 namespace WebCore {
     51 
     52 template <typename ResultType, typename CallbackArg>
     53 struct HelperResultType {
     54     typedef PassRefPtr<ResultType> ReturnType;
     55     typedef RefPtr<ResultType> StorageType;
     56 
     57     static ReturnType createFromCallbackArg(CallbackArg argument)
     58     {
     59         return ResultType::create(argument);
     60     }
     61 };
     62 
     63 template <>
     64 struct HelperResultType<EntrySyncVector, const EntryVector&> {
     65     typedef EntrySyncVector ReturnType;
     66     typedef EntrySyncVector StorageType;
     67 
     68     static EntrySyncVector createFromCallbackArg(const EntryVector& entries)
     69     {
     70         EntrySyncVector result;
     71         size_t entryCount = entries.size();
     72         result.reserveInitialCapacity(entryCount);
     73         for (size_t i = 0; i < entryCount; ++i)
     74             result.uncheckedAppend(EntrySync::create(entries[i].get()));
     75         return result;
     76     }
     77 };
     78 
     79 // A helper template for FileSystemSync implementation.
     80 template <typename SuccessCallback, typename CallbackArg, typename ResultType>
     81 class SyncCallbackHelper {
     82     WTF_MAKE_NONCOPYABLE(SyncCallbackHelper);
     83 public:
     84     typedef SyncCallbackHelper<SuccessCallback, CallbackArg, ResultType> HelperType;
     85     typedef HelperResultType<ResultType, CallbackArg> ResultTypeTrait;
     86     typedef typename ResultTypeTrait::StorageType ResultStorageType;
     87     typedef typename ResultTypeTrait::ReturnType ResultReturnType;
     88 
     89     SyncCallbackHelper()
     90         : m_errorCode(FileError::OK)
     91         , m_completed(false)
     92     {
     93     }
     94 
     95     ResultReturnType getResult(ExceptionState& exceptionState)
     96     {
     97         if (m_errorCode)
     98             FileError::throwDOMException(exceptionState, m_errorCode);
     99 
    100         return m_result;
    101     }
    102 
    103     PassOwnPtr<SuccessCallback> successCallback() { return SuccessCallbackImpl::create(this); }
    104     PassOwnPtr<ErrorCallback> errorCallback() { return ErrorCallbackImpl::create(this); }
    105 
    106 private:
    107     class SuccessCallbackImpl : public SuccessCallback {
    108     public:
    109         static PassOwnPtr<SuccessCallbackImpl> create(HelperType* helper)
    110         {
    111             return adoptPtr(new SuccessCallbackImpl(helper));
    112         }
    113 
    114         virtual void handleEvent()
    115         {
    116             m_helper->setError(FileError::OK);
    117         }
    118 
    119         virtual void handleEvent(CallbackArg arg)
    120         {
    121             m_helper->setResult(arg);
    122         }
    123 
    124     private:
    125         explicit SuccessCallbackImpl(HelperType* helper)
    126             : m_helper(helper)
    127         {
    128         }
    129         HelperType* m_helper;
    130     };
    131 
    132     class ErrorCallbackImpl : public ErrorCallback {
    133     public:
    134         static PassOwnPtr<ErrorCallbackImpl> create(HelperType* helper)
    135         {
    136             return adoptPtr(new ErrorCallbackImpl(helper));
    137         }
    138 
    139         virtual void handleEvent(FileError* error)
    140         {
    141             ASSERT(error);
    142             m_helper->setError(error->code());
    143         }
    144 
    145     private:
    146         explicit ErrorCallbackImpl(HelperType* helper)
    147             : m_helper(helper)
    148         {
    149         }
    150         HelperType* m_helper;
    151     };
    152 
    153     void setError(FileError::ErrorCode code)
    154     {
    155         m_errorCode = code;
    156         m_completed = true;
    157     }
    158 
    159     void setResult(CallbackArg result)
    160     {
    161         m_result = ResultTypeTrait::createFromCallbackArg(result);
    162         m_completed = true;
    163     }
    164 
    165     ResultStorageType m_result;
    166     FileError::ErrorCode m_errorCode;
    167     bool m_completed;
    168 };
    169 
    170 struct EmptyType : public RefCounted<EmptyType> {
    171     static PassRefPtr<EmptyType> create(EmptyType*)
    172     {
    173         return 0;
    174     }
    175 };
    176 
    177 typedef SyncCallbackHelper<EntryCallback, Entry*, EntrySync> EntrySyncCallbackHelper;
    178 typedef SyncCallbackHelper<EntriesCallback, const EntryVector&, EntrySyncVector> EntriesSyncCallbackHelper;
    179 typedef SyncCallbackHelper<MetadataCallback, Metadata*, Metadata> MetadataSyncCallbackHelper;
    180 typedef SyncCallbackHelper<VoidCallback, EmptyType*, EmptyType> VoidSyncCallbackHelper;
    181 typedef SyncCallbackHelper<FileSystemCallback, DOMFileSystem*, DOMFileSystemSync> FileSystemSyncCallbackHelper;
    182 
    183 } // namespace WebCore
    184 
    185 #endif // SyncCallbackHelper_h
    186