Replace EntryArraySync type by an EntrySync[]

Source/modules/filesystem/SyncCallbackHelper.h

 /*
  * Copyright (C) 2010 Google Inc. All rights reserved.
+ * Copyright (C) 2013 Samsung Electronics. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are
  * met:
  *
  *     * Redistributions of source code must retain the above copyright
  * notice, this list of conditions and the following disclaimer.
  *     * Redistributions in binary form must reproduce the above
  * copyright notice, this list of conditions and the following disclaimer
  * in the documentation and/or other materials provided with the
@@ skipping 15 matching lines @@
  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
 #ifndef SyncCallbackHelper_h
 #define SyncCallbackHelper_h
 
 #include "bindings/v8/ExceptionState.h"
 #include "core/fileapi/FileError.h"
 #include "core/html/VoidCallback.h"
 #include "modules/filesystem/DirectoryEntry.h"
+#include "modules/filesystem/DirectoryReaderSync.h"
 #include "modules/filesystem/EntriesCallback.h"
-#include "modules/filesystem/EntryArraySync.h"
 #include "modules/filesystem/EntryCallback.h"
+#include "modules/filesystem/EntrySync.h"
 #include "modules/filesystem/ErrorCallback.h"
 #include "modules/filesystem/FileEntry.h"
 #include "modules/filesystem/FileSystemCallback.h"
 #include "modules/filesystem/MetadataCallback.h"
 #include "wtf/PassRefPtr.h"
 #include "wtf/RefCounted.h"
 
 namespace WebCore {
 
 class AsyncFileSystem;
 class DirectoryEntrySync;
 class EntryArraySync;

[kinuko, 2013/08/08 11:39:19]

nit: obsolete

 class EntrySync;
 class FileEntrySync;

[kinuko, 2013/08/08 11:39:19]

I guess actually we can remove all these forward decls?

 
 // A helper template for FileSystemSync implementation.
-template <typename SuccessCallback, typename ObserverType, typename CallbackArg, typename ResultType>
-class SyncCallbackHelper {
-    WTF_MAKE_NONCOPYABLE(SyncCallbackHelper);
+template <typename SuccessCallback, typename ObserverType, typename CallbackArg>
+class SyncCallbackHelperBase {
+    WTF_MAKE_NONCOPYABLE(SyncCallbackHelperBase);
 public:
-    typedef SyncCallbackHelper<SuccessCallback, ObserverType, CallbackArg, ResultType> HelperType;
-    SyncCallbackHelper(ObserverType* observer = 0)
+    typedef SyncCallbackHelperBase<SuccessCallback, ObserverType, CallbackArg> HelperType;
+    SyncCallbackHelperBase(ObserverType* observer)
         : m_observer(observer)
         , m_successCallback(SuccessCallbackImpl::create(this))
         , m_errorCallback(ErrorCallbackImpl::create(this))
         , m_errorCode(FileError::OK)
         , m_completed(false)
     {
     }
 
-    PassRefPtr<ResultType> getResult(ExceptionState& es)
-    {
-        if (m_observer) {
-            while (!m_completed) {
-                if (!m_observer->waitForOperationToComplete()) {
-                    m_errorCode = FileError::ABORT_ERR;
-                    break;
-                }
-            }
-        }
-        if (m_errorCode)
-            FileError::throwDOMException(es, m_errorCode);
-
-        return m_result.release();
-    }
-
     PassRefPtr<SuccessCallback> successCallback() { return m_successCallback; }
     PassRefPtr<ErrorCallback> errorCallback() { return m_errorCallback; }
 
-private:
+protected:
     class SuccessCallbackImpl : public SuccessCallback {
     public:
         static PassRefPtr<SuccessCallbackImpl> create(HelperType* helper)
         {
             return adoptRef(new SuccessCallbackImpl(helper));
         }
 
         virtual bool handleEvent()
         {
             m_helper->setError(FileError::OK);
             return true;
         }
 
         virtual bool handleEvent(CallbackArg arg)
         {
-            m_helper->setResult(ResultType::create(arg));
+            m_helper->setResult(arg);
             return true;
         }
 
     private:
         explicit SuccessCallbackImpl(HelperType* helper)
             : m_helper(helper)
         {
         }
         HelperType* m_helper;
     };
@@ skipping 22 matching lines @@
 
     friend class SuccessCallbackImpl;
     friend class ErrorCallbackImpl;
 
     void setError(FileError::ErrorCode code)
     {
         m_errorCode = code;
         m_completed = true;
     }
 
-    void setResult(PassRefPtr<ResultType> result)
+    void waitForCompletion(ExceptionState& es)
     {
-        m_result = result;
-        m_completed = true;
+        if (m_observer) {
+            while (!m_completed) {
+                if (!m_observer->waitForOperationToComplete()) {
+                    m_errorCode = FileError::ABORT_ERR;
+                    break;
+                }
+            }
+        }
+        if (m_errorCode)
+            FileError::throwDOMException(es, m_errorCode);
     }
 
+    virtual void setResult(CallbackArg) = 0;
+
     ObserverType* m_observer;
     RefPtr<SuccessCallbackImpl> m_successCallback;
     RefPtr<ErrorCallbackImpl> m_errorCallback;
-    RefPtr<ResultType> m_result;
     FileError::ErrorCode m_errorCode;
     bool m_completed;
 };
 
+template <typename SuccessCallback, typename ObserverType, typename CallbackArg, typename ResultType>

[kinuko, 2013/08/08 11:39:19]

Could this change become simpler if we define traits classes for ResultTypes and
keep the remaining logic as is?

The traits can define types like ReturnType, StorageType and static methods like
getValue, setValue.

(If you think it'd make the code rather complicated current code is fine too)

+class SyncCallbackHelper : public SyncCallbackHelperBase<SuccessCallback, ObserverType, CallbackArg> {
+    WTF_MAKE_NONCOPYABLE(SyncCallbackHelper);
+public:
+    SyncCallbackHelper(ObserverType* observer = 0)
+        : SyncCallbackHelperBase<SuccessCallback, ObserverType, CallbackArg>(observer)
+    {
+    }
+
+    PassRefPtr<ResultType> getResult(ExceptionState& es)
+    {
+        SyncCallbackHelperBase<SuccessCallback, ObserverType, CallbackArg>::waitForCompletion(es);
+
+        return m_result.release();
+    }
+
+private:
+    virtual void setResult(CallbackArg result)
+    {
+        m_result = ResultType::create(result);
+        SyncCallbackHelperBase<SuccessCallback, ObserverType, CallbackArg>::m_completed = true;
+    }
+
+    RefPtr<ResultType> m_result;
+};
+
+// Partial specialization for EntryVector / EntrySyncVector.
+template <typename SuccessCallback, typename ObserverType>
+class SyncCallbackHelper<SuccessCallback, ObserverType, const EntryVector&, EntrySyncVector> : public SyncCallbackHelperBase<SuccessCallback, ObserverType, const EntryVector&> {
+    WTF_MAKE_NONCOPYABLE(SyncCallbackHelper);
+public:
+    SyncCallbackHelper(ObserverType* observer = 0)
+        : SyncCallbackHelperBase<SuccessCallback, ObserverType, const EntryVector&>(observer)
+    {
+    }
+
+    EntrySyncVector getResult(ExceptionState& es)
+    {
+        SyncCallbackHelperBase<SuccessCallback, ObserverType, const EntryVector&>::waitForCompletion(es);
+
+        return m_result;
+    }
+
+private:
+    virtual void setResult(const EntryVector& result)
+    {
+        size_t entryCount = result.size();
+        m_result.resize(entryCount);
+        for (size_t i = 0; i < entryCount; ++i)
+            m_result[i] = EntrySync::create(result[i].get());
+        SyncCallbackHelperBase<SuccessCallback, ObserverType, const EntryVector&>::m_completed = true;
+    }
+
+    EntrySyncVector m_result;
+};
+
 struct EmptyType : public RefCounted<EmptyType> {
     static PassRefPtr<EmptyType> create(EmptyType*)
     {
         return 0;
     }
 };
 
 struct EmptyObserverType {
     bool waitForOperationToComplete()
     {
         return false;
     }
 };
 
 typedef SyncCallbackHelper<EntryCallback, AsyncFileSystem, Entry*, EntrySync> EntrySyncCallbackHelper;
-typedef SyncCallbackHelper<EntriesCallback, AsyncFileSystem, const EntryVector&, EntryArraySync> EntriesSyncCallbackHelper;
+typedef SyncCallbackHelper<EntriesCallback, AsyncFileSystem, const EntryVector&, EntrySyncVector> EntriesSyncCallbackHelper;
 typedef SyncCallbackHelper<MetadataCallback, AsyncFileSystem, Metadata*, Metadata> MetadataSyncCallbackHelper;
 typedef SyncCallbackHelper<VoidCallback, AsyncFileSystem, EmptyType*, EmptyType> VoidSyncCallbackHelper;
 typedef SyncCallbackHelper<FileSystemCallback, EmptyObserverType, DOMFileSystem*, DOMFileSystemSync> FileSystemSyncCallbackHelper;
 
 } // namespace WebCore
 
 #endif // SyncCallbackHelper_h