gdata: Move task related functions like RunTaskOnUIThread from gdata_file_system.cc to task_util.cc

chrome/browser/chromeos/gdata/gdata_file_system.cc

 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "chrome/browser/chromeos/gdata/gdata_file_system.h"
 
 #include <set>
 #include <utility>
 
 #include "base/bind.h"
 #include "base/file_util.h"
 #include "base/json/json_file_value_serializer.h"
 #include "base/message_loop.h"
 #include "base/message_loop_proxy.h"
 #include "base/metrics/histogram.h"
 #include "base/platform_file.h"
 #include "base/threading/sequenced_worker_pool.h"
 #include "base/values.h"
 #include "chrome/browser/chromeos/gdata/drive_api_parser.h"
 #include "chrome/browser/chromeos/gdata/drive_webapps_registry.h"
 #include "chrome/browser/chromeos/gdata/gdata.pb.h"
 #include "chrome/browser/chromeos/gdata/gdata_documents_service.h"
 #include "chrome/browser/chromeos/gdata/gdata_download_observer.h"
 #include "chrome/browser/chromeos/gdata/gdata_files.h"
 #include "chrome/browser/chromeos/gdata/gdata_protocol_handler.h"
 #include "chrome/browser/chromeos/gdata/gdata_system_service.h"
 #include "chrome/browser/chromeos/gdata/gdata_uploader.h"
 #include "chrome/browser/chromeos/gdata/gdata_util.h"
+#include "chrome/browser/chromeos/gdata/task_util.h"
 #include "chrome/browser/prefs/pref_service.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/common/chrome_notification_types.h"
 #include "chrome/common/pref_names.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/notification_details.h"
 #include "net/base/mime_util.h"
 
 using content::BrowserThread;
 
@@ skipping 191 matching lines @@
 void CopyLocalFileOnBlockingPool(
     const FilePath& src_file_path,
     const FilePath& dest_file_path,
     GDataFileError* error) {
   DCHECK(error);
 
   *error = file_util::CopyFile(src_file_path, dest_file_path) ?
       GDATA_FILE_OK : GDATA_FILE_ERROR_FAILED;
 }
 
-// Runs task on the thread to which |relay_proxy| belongs.
-void RunTaskOnThread(scoped_refptr<base::MessageLoopProxy> relay_proxy,
-                     const base::Closure& task) {
-  if (relay_proxy->BelongsToCurrentThread()) {
-    task.Run();
-  } else {
-    const bool posted = relay_proxy->PostTask(FROM_HERE, task);
-    DCHECK(posted);
-  }
-}
-
 // Callback for GetEntryByResourceIdAsync.
 // Adds |entry| to |results|. Runs |callback| with |results| when
 // |run_callback| is true. When |entry| is not present in our local file system
 // snapshot, it is not added to |results|. Instead, |entry_skipped_callback| is
 // called.
 void AddEntryToSearchResults(
     std::vector<SearchResultInfo>* results,
     const SearchCallback& callback,
     const base::Closure& entry_skipped_callback,
     GDataFileError error,
@@ skipping 12 matching lines @@
       entry_skipped_callback.Run();
   }
 
   if (run_callback) {
     scoped_ptr<std::vector<SearchResultInfo> > result_vec(results);
     if (!callback.is_null())
       callback.Run(error, next_feed, result_vec.Pass());
   }
 }
 
-// Runs task on UI thread.
-void RunTaskOnUIThread(const base::Closure& task) {
-  RunTaskOnThread(
-      BrowserThread::GetMessageLoopProxyForThread(BrowserThread::UI), task);
-}
-
-// RelayCallback relays arguments for callback running on the given thread.
-template<typename CallbackType>
-struct RelayCallback;
-
-// RelayCallback for callback with one argument.
-template<typename T1>
-struct RelayCallback<base::Callback<void(T1)> > {
-  static void Run(scoped_refptr<base::MessageLoopProxy> relay_proxy,
-                  const base::Callback<void(T1)>& callback,
-                  T1 arg1) {
-    if (callback.is_null())
-      return;
-    RunTaskOnThread(relay_proxy, base::Bind(callback, arg1));
-  }
-};
-
-// RelayCallback for callback with two arguments.
-template<typename T1, typename T2>
-struct RelayCallback<base::Callback<void(T1, T2)> > {
-  static void Run(scoped_refptr<base::MessageLoopProxy> relay_proxy,
-                  const base::Callback<void(T1, T2)>& callback,
-                  T1 arg1,
-                  T2 arg2) {
-    if (callback.is_null())
-      return;
-    RunTaskOnThread(relay_proxy, base::Bind(callback, arg1, arg2));
-  }
-};
-
-// RelayCallback for callback with two arguments, the last one is scoped_ptr.
-template<typename T1, typename T2>
-struct RelayCallback<base::Callback<void(T1, scoped_ptr<T2>)> > {
-  static void Run(scoped_refptr<base::MessageLoopProxy> relay_proxy,
-                  const base::Callback<void(T1, scoped_ptr<T2>)>& callback,
-                  T1 arg1,
-                  scoped_ptr<T2> arg2) {
-    if (callback.is_null())
-      return;
-    RunTaskOnThread(relay_proxy,
-                    base::Bind(callback, arg1, base::Passed(&arg2)));
-  }
-};
-
-// RelayCallback for callback with three arguments.
-template<typename T1, typename T2, typename T3>
-struct RelayCallback<base::Callback<void(T1, T2, T3)> > {
-  static void Run(scoped_refptr<base::MessageLoopProxy> relay_proxy,
-                  const base::Callback<void(T1, T2, T3)>& callback,
-                  T1 arg1,
-                  T2 arg2,
-                  T3 arg3) {
-    if (callback.is_null())
-      return;
-    RunTaskOnThread(relay_proxy, base::Bind(callback, arg1, arg2, arg3));
-  }
-};
-
-// RelayCallback for callback with three arguments, the last one is scoped_ptr.
-template<typename T1, typename T2, typename T3>
-struct RelayCallback<base::Callback<void(T1, T2, scoped_ptr<T3>)> > {
-  static void Run(scoped_refptr<base::MessageLoopProxy> relay_proxy,
-                  const base::Callback<void(T1, T2, scoped_ptr<T3>)>& callback,
-                  T1 arg1,
-                  T2 arg2,
-                  scoped_ptr<T3> arg3) {
-    if (callback.is_null())
-      return;
-    RunTaskOnThread(relay_proxy,
-                    base::Bind(callback, arg1, arg2, base::Passed(&arg3)));
-  }
-};
-
-// RelayCallback for callback with four arguments.
-template<typename T1, typename T2, typename T3, typename T4>
-struct RelayCallback<base::Callback<void(T1, T2, T3, T4)> > {
-  static void Run(scoped_refptr<base::MessageLoopProxy> relay_proxy,
-                  const base::Callback<void(T1, T2, T3, T4)>& callback,
-                  T1 arg1,
-                  T2 arg2,
-                  T3 arg3,
-                  T4 arg4) {
-    if (callback.is_null())
-      return;
-    RunTaskOnThread(relay_proxy, base::Bind(callback, arg1, arg2, arg3, arg4));
-  }
-};
-
-// Returns callback which runs the given |callback| on the current thread.
-template<typename CallbackType>
-CallbackType CreateRelayCallback(const CallbackType& callback) {
-  return base::Bind(&RelayCallback<CallbackType>::Run,
-                    base::MessageLoopProxy::current(),
-                    callback);
-}
-
 // Helper function for binding |path| to GetEntryInfoWithFilePathCallback and
 // create GetEntryInfoCallback.
 void RunGetEntryInfoWithFilePathCallback(
     const GetEntryInfoWithFilePathCallback& callback,
     const FilePath& path,
     GDataFileError error,
     scoped_ptr<GDataEntryProto> entry_proto) {
   if (!callback.is_null())
     callback.Run(error, path, entry_proto.Pass());
 }
@@ skipping 3048 matching lines @@
     return;
   }
 
   PlatformFileInfoProto entry_file_info;
   GDataEntry::ConvertPlatformFileInfoToProto(*file_info, &entry_file_info);
   *entry_proto->mutable_file_info() = entry_file_info;
   callback.Run(GDATA_FILE_OK, entry_proto.Pass());
 }
 
 }  // namespace gdata