Replace EntryArraySync type by an EntrySync[]

Source/modules/filesystem/SyncCallbackHelper.h

Index: Source/modules/filesystem/SyncCallbackHelper.h
diff --git a/Source/modules/filesystem/SyncCallbackHelper.h b/Source/modules/filesystem/SyncCallbackHelper.h
index 7ef045d065dd128df8caf1e84e3e67eeec851ced..875e4e62386bb5d754158f5fc5bea020b2f57417 100644
--- a/Source/modules/filesystem/SyncCallbackHelper.h
+++ b/Source/modules/filesystem/SyncCallbackHelper.h
@@ -1,5 +1,6 @@
 /*
  * 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
@@ -35,9 +36,10 @@
 #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"
@@ -54,12 +56,12 @@ 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))
@@ -68,26 +70,10 @@ public:
     {
     }
 
-    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)
@@ -103,7 +89,7 @@ private:
 
         virtual bool handleEvent(CallbackArg arg)
         {
-            m_helper->setResult(ResultType::create(arg));
+            m_helper->setResult(arg);
             return true;
         }
 
@@ -146,20 +132,85 @@ private:
         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*)
     {
@@ -175,7 +226,7 @@ struct EmptyObserverType {
 };
 
 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;