gdata: Move GDataWapiFeedLoader to a set of new files

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/command_line.h"
 #include "base/file_util.h"
 #include "base/json/json_file_value_serializer.h"
-#include "base/json/json_reader.h"
-#include "base/json/json_writer.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_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_protocol_handler.h"
 #include "chrome/browser/chromeos/gdata/gdata_system_service.h"
 #include "chrome/browser/chromeos/gdata/gdata_util.h"
 #include "chrome/browser/prefs/pref_service.h"
 #include "chrome/browser/profiles/profile.h"
-#include "chrome/common/chrome_switches.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;
 
 namespace gdata {
 namespace {
 
 const char kMimeTypeJson[] = "application/json";
 const char kMimeTypeOctetStream[] = "application/octet-stream";
 
-const FilePath::CharType kAccountMetadataFile[] =
-    FILE_PATH_LITERAL("account_metadata.json");
-const FilePath::CharType kFilesystemProtoFile[] =
-    FILE_PATH_LITERAL("file_system.pb");
-const FilePath::CharType kResourceMetadataDBFile[] =
-    FILE_PATH_LITERAL("resource_metadata.db");
-
 const char kEmptyFilePath[] = "/dev/null";
 
 // GData update check interval (in seconds).
 #ifndef NDEBUG
 const int kGDataUpdateCheckIntervalInSec = 5;
 #else
 const int kGDataUpdateCheckIntervalInSec = 60;
 #endif
 
-// Update the fetch progress UI per every this number of feeds.
-const int kFetchUiUpdateStep = 10;
-
-// Schedule for dumping root file system proto buffers to disk depending its
-// total protobuffer size in MB.
-typedef struct {
-  double size;
-  int timeout;
-} SerializationTimetable;
-
-SerializationTimetable kSerializeTimetable[] = {
-#ifndef NDEBUG
-    {0.5, 0},    // Less than 0.5MB, dump immediately.
-    {-1,  1},    // Any size, dump if older than 1 minute.
-#else
-    {0.5, 0},    // Less than 0.5MB, dump immediately.
-    {1.0, 15},   // Less than 1.0MB, dump after 15 minutes.
-    {2.0, 30},
-    {4.0, 60},
-    {-1,  120},  // Any size, dump if older than 120 minutes.
-#endif
-};
-
-// Returns true if file system is due to be serialized on disk based on it
-// |serialized_size| and |last_serialized| timestamp.
-bool ShouldSerializeFileSystemNow(size_t serialized_size,
-                                  const base::Time& last_serialized) {
-  const double size_in_mb = serialized_size / 1048576.0;
-  const int last_proto_dump_in_min =
-      (base::Time::Now() - last_serialized).InMinutes();
-  for (size_t i = 0; i < arraysize(kSerializeTimetable); i++) {
-    if ((size_in_mb < kSerializeTimetable[i].size ||
-         kSerializeTimetable[i].size == -1) &&
-        last_proto_dump_in_min >= kSerializeTimetable[i].timeout) {
-      return true;
-    }
-  }
-  return false;
-}
-
-// Converts gdata error code into file platform error code.
-GDataFileError GDataToGDataFileError(GDataErrorCode status) {
-  switch (status) {
-    case HTTP_SUCCESS:
-    case HTTP_CREATED:
-      return GDATA_FILE_OK;
-    case HTTP_UNAUTHORIZED:
-    case HTTP_FORBIDDEN:
-      return GDATA_FILE_ERROR_ACCESS_DENIED;
-    case HTTP_NOT_FOUND:
-      return GDATA_FILE_ERROR_NOT_FOUND;
-    case GDATA_PARSE_ERROR:
-    case GDATA_FILE_ERROR:
-      return GDATA_FILE_ERROR_ABORT;
-    case GDATA_NO_CONNECTION:
-      return GDATA_FILE_ERROR_NO_CONNECTION;
-    default:
-      return GDATA_FILE_ERROR_FAILED;
-  }
-}
-
 //================================ Helper functions ============================
 
 // Invoked upon completion of TransferRegularFile initiated by Copy.
 //
 // |callback| is run on the thread represented by |relay_proxy|.
 void OnTransferRegularFileCompleteForCopy(
     const FileOperationCallback& callback,
     scoped_refptr<base::MessageLoopProxy> relay_proxy,
     GDataFileError error) {
   if (!callback.is_null())
@@ skipping 60 matching lines @@
       base::MessageLoopProxy::current()->PostTask(FROM_HERE, callback_);
     file_system_->RemoveObserver(this);
     base::MessageLoopProxy::current()->DeleteSoon(FROM_HERE, this);
   }
 
  private:
   GDataFileSystemInterface* file_system_;
   base::Closure callback_;
 };
 
-// Saves the string |serialized_proto| to a file at |path| on a blocking thread.
-void SaveProtoOnBlockingPool(const FilePath& path,
-                             scoped_ptr<std::string> serialized_proto) {
-  const int file_size = static_cast<int>(serialized_proto->length());
-  if (file_util::WriteFile(path, serialized_proto->data(), file_size) !=
-      file_size) {
-    LOG(WARNING) << "GData proto file can't be stored at "
-                 << path.value();
-    if (!file_util::Delete(path, true)) {
-      LOG(WARNING) << "GData proto file can't be deleted at "
-                   << path.value();
-    }
-  }
-}
-
-// Loads the file at |path| into the string |serialized_proto| on a blocking
-// thread.
-void LoadProtoOnBlockingPool(const FilePath& path,
-                             LoadRootFeedParams* params) {
-  base::PlatformFileInfo info;
-  if (!file_util::GetFileInfo(path, &info)) {
-    params->load_error = GDATA_FILE_ERROR_NOT_FOUND;
-    return;
-  }
-  params->last_modified = info.last_modified;
-  if (!file_util::ReadFileToString(path, &params->proto)) {
-    LOG(WARNING) << "Proto file not found at " << path.value();
-    params->load_error = GDATA_FILE_ERROR_NOT_FOUND;
-    return;
-  }
-  params->load_error = GDATA_FILE_OK;
-}
-
-// Saves json file content content in |feed| to |file_pathname| on blocking
-// pool. Used for debugging.
-void SaveFeedOnBlockingPoolForDebugging(
-    const FilePath& file_path,
-    scoped_ptr<base::Value> feed) {
-  std::string json;
-  base::JSONWriter::WriteWithOptions(feed.get(),
-                                     base::JSONWriter::OPTIONS_PRETTY_PRINT,
-                                     &json);
-
-  int file_size = static_cast<int>(json.length());
-  if (file_util::WriteFile(file_path, json.data(), file_size) != file_size) {
-    LOG(WARNING) << "GData metadata file can't be stored at "
-                 << file_path.value();
-    if (!file_util::Delete(file_path, true)) {
-      LOG(WARNING) << "GData metadata file can't be deleted at "
-                   << file_path.value();
-      return;
-    }
-  }
-}
-
-bool UseLevelDB() {
-  return CommandLine::ForCurrentProcess()->HasSwitch(
-      switches::kUseLevelDBForGData);
-}
-
 // Gets the file size of |local_file|.
 void GetLocalFileSizeOnBlockingPool(const FilePath& local_file,
                                     GDataFileError* error,
                                     int64* file_size) {
   DCHECK(error);
   DCHECK(file_size);
 
   *file_size = 0;
   *error = file_util::GetFileSize(local_file, file_size) ?
       GDATA_FILE_OK :
@@ skipping 230 matching lines @@
 };
 
 // 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);
 }
 
-// Wrapper around BrowserThread::PostTask to post a task to the blocking
-// pool with the given sequence token.
-void PostBlockingPoolSequencedTask(
-    const tracked_objects::Location& from_here,
-    base::SequencedTaskRunner* blocking_task_runner,
-    const base::Closure& task) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
-
-  const bool posted = blocking_task_runner->PostTask(from_here, task);
-  DCHECK(posted);
-}
-
-// Similar to PostBlockingPoolSequencedTask() but this one takes a reply
-// callback that runs on the calling thread.
-void PostBlockingPoolSequencedTaskAndReply(
-    const tracked_objects::Location& from_here,
-    base::SequencedTaskRunner* blocking_task_runner,
-    const base::Closure& request_task,
-    const base::Closure& reply_task) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
-
-  const bool posted = blocking_task_runner->PostTaskAndReply(
-      from_here, request_task, reply_task);
-  DCHECK(posted);
-}
-
 // 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());
 }
 
 }  // namespace
 
-GDataWapiFeedLoader::GDataWapiFeedLoader(
-    GDataDirectoryService* directory_service,
-    DocumentsServiceInterface* documents_service,
-    DriveWebAppsRegistryInterface* webapps_registry,
-    GDataCache* cache,
-    scoped_refptr<base::SequencedTaskRunner> blocking_task_runner)
-    : directory_service_(directory_service),
-      documents_service_(documents_service),
-      webapps_registry_(webapps_registry),
-      cache_(cache),
-      blocking_task_runner_(blocking_task_runner),
-      weak_ptr_factory_(ALLOW_THIS_IN_INITIALIZER_LIST(this)) {
-}
-
-GDataWapiFeedLoader::~GDataWapiFeedLoader() {
-}
-
-void GDataWapiFeedLoader::AddObserver(Observer* observer) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
-  observers_.AddObserver(observer);
-}
-
-void GDataWapiFeedLoader::RemoveObserver(Observer* observer) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
-  observers_.RemoveObserver(observer);
-}
-
-// Defines set of parameters sent to callback OnNotifyDocumentFeedFetched().
-// This is a trick to update the number of fetched documents frequently on
-// UI. Due to performance reason, we need to fetch a number of files at
-// a time. However, it'll take long time, and a user has no way to know
-// the current update state. In order to make users confortable,
-// we increment the number of fetched documents with more frequent but smaller
-// steps than actual fetching.
-struct GetDocumentsUiState {
-  explicit GetDocumentsUiState(base::TimeTicks start_time)
-      : num_fetched_documents(0),
-        num_showing_documents(0),
-        start_time(start_time),
-        weak_ptr_factory(this) {
-  }
-
-  // The number of fetched documents.
-  int num_fetched_documents;
-
-  // The number documents shown on UI.
-  int num_showing_documents;
-
-  // When the UI update has started.
-  base::TimeTicks start_time;
-
-  // Time elapsed since the feed fetching was started.
-  base::TimeDelta feed_fetching_elapsed_time;
-
-  base::WeakPtrFactory<GetDocumentsUiState> weak_ptr_factory;
-};
-
-// Defines set of parameters sent to callback OnGetDocuments().
-// TODO(satorux): Move this to a new file: crbug.com/138268
-struct GetDocumentsParams {
-  GetDocumentsParams(int start_changestamp,
-                     int root_feed_changestamp,
-                     std::vector<DocumentFeed*>* feed_list,
-                     bool should_fetch_multiple_feeds,
-                     const FilePath& search_file_path,
-                     const std::string& search_query,
-                     const std::string& directory_resource_id,
-                     const FindEntryCallback& callback,
-                     GetDocumentsUiState* ui_state);
-  ~GetDocumentsParams();
-
-  // Changestamps are positive numbers in increasing order. The difference
-  // between two changestamps is proportional equal to number of items in
-  // delta feed between them - bigger the difference, more likely bigger
-  // number of items in delta feeds.
-  int start_changestamp;
-  int root_feed_changestamp;
-  scoped_ptr<std::vector<DocumentFeed*> > feed_list;
-  // Should we stop after getting first feed chunk, even if there is more
-  // data.
-  bool should_fetch_multiple_feeds;
-  FilePath search_file_path;
-  std::string search_query;
-  std::string directory_resource_id;
-  FindEntryCallback callback;
-  scoped_ptr<GetDocumentsUiState> ui_state;
-};
-
-GetDocumentsParams::GetDocumentsParams(
-    int start_changestamp,
-    int root_feed_changestamp,
-    std::vector<DocumentFeed*>* feed_list,
-    bool should_fetch_multiple_feeds,
-    const FilePath& search_file_path,
-    const std::string& search_query,
-    const std::string& directory_resource_id,
-    const FindEntryCallback& callback,
-    GetDocumentsUiState* ui_state)
-    : start_changestamp(start_changestamp),
-      root_feed_changestamp(root_feed_changestamp),
-      feed_list(feed_list),
-      should_fetch_multiple_feeds(should_fetch_multiple_feeds),
-      search_file_path(search_file_path),
-      search_query(search_query),
-      directory_resource_id(directory_resource_id),
-      callback(callback),
-      ui_state(ui_state) {
-}
-
-GetDocumentsParams::~GetDocumentsParams() {
-  STLDeleteElements(feed_list.get());
-}
-
 // GDataFileSystem::CreateDirectoryParams struct implementation.
 struct GDataFileSystem::CreateDirectoryParams {
   CreateDirectoryParams(const FilePath& created_directory_path,
                         const FilePath& target_directory_path,
                         bool is_exclusive,
                         bool is_recursive,
                         const FileOperationCallback& callback);
   ~CreateDirectoryParams();
 
   const FilePath created_directory_path;
@@ skipping 293 matching lines @@
 }
 
 void GDataFileSystem::FindEntryByPathSyncOnUIThread(
     const FilePath& search_file_path,
     const FindEntryCallback& callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   directory_service_->FindEntryByPathAndRunSync(search_file_path, callback);
 }
 
-void GDataWapiFeedLoader::ReloadFromServerIfNeeded(
-    ContentOrigin initial_origin,
-    int local_changestamp,
-    const FilePath& search_file_path,
-    const FindEntryCallback& callback) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
-
-  DVLOG(1) << "ReloadFeedFromServerIfNeeded local_changestamp="
-           << local_changestamp << ", initial_origin=" << initial_origin;
-
-  // First fetch the latest changestamp to see if there were any new changes
-  // there at all.
-  documents_service_->GetAccountMetadata(
-      base::Bind(&GDataWapiFeedLoader::OnGetAccountMetadata,
-                 weak_ptr_factory_.GetWeakPtr(),
-                 initial_origin,
-                 local_changestamp,
-                 search_file_path,
-                 callback));
-}
-
-void GDataWapiFeedLoader::OnGetAccountMetadata(
-    ContentOrigin initial_origin,
-    int local_changestamp,
-    const FilePath& search_file_path,
-    const FindEntryCallback& callback,
-    GDataErrorCode status,
-    scoped_ptr<base::Value> feed_data) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
-
-  GDataFileError error = GDataToGDataFileError(status);
-  if (error != GDATA_FILE_OK) {
-    // Get changes starting from the next changestamp from what we have locally.
-    LoadFromServer(initial_origin,
-                   local_changestamp + 1, 0,
-                   true,  /* should_fetch_multiple_feeds */
-                   search_file_path,
-                   std::string() /* no search query */,
-                   GURL(), /* feed not explicitly set */
-                   std::string() /* no directory resource ID */,
-                   callback,
-                   base::Bind(&GDataWapiFeedLoader::OnFeedFromServerLoaded,
-                              weak_ptr_factory_.GetWeakPtr()));
-    return;
-  }
-
-  scoped_ptr<AccountMetadataFeed> account_metadata;
-  if (feed_data.get()) {
-    account_metadata = AccountMetadataFeed::CreateFrom(*feed_data);
-#ifndef NDEBUG
-    // Save account metadata feed for analysis.
-    const FilePath path =
-        cache_->GetCacheDirectoryPath(GDataCache::CACHE_TYPE_META).Append(
-            kAccountMetadataFile);
-    PostBlockingPoolSequencedTask(
-        FROM_HERE,
-        blocking_task_runner_,
-        base::Bind(&SaveFeedOnBlockingPoolForDebugging,
-                   path, base::Passed(&feed_data)));
-#endif
-  }
-
-  if (!account_metadata.get()) {
-    LoadFromServer(initial_origin,
-                   local_changestamp + 1, 0,
-                   true,  /* should_fetch_multiple_feeds */
-                   search_file_path,
-                   std::string() /* no search query */,
-                   GURL(), /* feed not explicitly set */
-                   std::string() /* no directory resource ID */,
-                   callback,
-                   base::Bind(&GDataWapiFeedLoader::OnFeedFromServerLoaded,
-                              weak_ptr_factory_.GetWeakPtr()));
-    return;
-  }
-
-  webapps_registry_->UpdateFromFeed(account_metadata.get());
-
-  bool changes_detected = true;
-  if (local_changestamp >= account_metadata->largest_changestamp()) {
-    if (local_changestamp > account_metadata->largest_changestamp()) {
-      LOG(WARNING) << "Cached client feed is fresher than server, client = "
-                   << local_changestamp
-                   << ", server = "
-                   << account_metadata->largest_changestamp();
-    }
-    // If our cache holds the latest state from the server, change the
-    // state to FROM_SERVER.
-    directory_service_->set_origin(
-        initial_origin == FROM_CACHE ? FROM_SERVER : initial_origin);
-    changes_detected = false;
-  }
-
-  // No changes detected, continue with search as planned.
-  if (!changes_detected) {
-    if (!callback.is_null()) {
-      directory_service_->FindEntryByPathAndRunSync(search_file_path,
-                                                    callback);
-    }
-    return;
-  }
-
-  // Load changes from the server.
-  LoadFromServer(initial_origin,
-                 local_changestamp > 0 ? local_changestamp + 1 : 0,
-                 account_metadata->largest_changestamp(),
-                 true,  /* should_fetch_multiple_feeds */
-                 search_file_path,
-                 std::string() /* no search query */,
-                 GURL(), /* feed not explicitly set */
-                 std::string() /* no directory resource ID */,
-                 callback,
-                 base::Bind(&GDataWapiFeedLoader::OnFeedFromServerLoaded,
-                            weak_ptr_factory_.GetWeakPtr()));
-}
-
-void GDataWapiFeedLoader::LoadFromServer(
-    ContentOrigin initial_origin,
-    int start_changestamp,
-    int root_feed_changestamp,
-    bool should_fetch_multiple_feeds,
-    const FilePath& search_file_path,
-    const std::string& search_query,
-    const GURL& feed_to_load,
-    const std::string& directory_resource_id,
-    const FindEntryCallback& entry_found_callback,
-    const LoadDocumentFeedCallback& feed_load_callback) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
-
-  // |feed_list| will contain the list of all collected feed updates that
-  // we will receive through calls of DocumentsService::GetDocuments().
-  scoped_ptr<std::vector<DocumentFeed*> > feed_list(
-      new std::vector<DocumentFeed*>);
-  const base::TimeTicks start_time = base::TimeTicks::Now();
-  documents_service_->GetDocuments(
-      feed_to_load,
-      start_changestamp,
-      search_query,
-      directory_resource_id,
-      base::Bind(&GDataWapiFeedLoader::OnGetDocuments,
-                 weak_ptr_factory_.GetWeakPtr(),
-                 initial_origin,
-                 feed_load_callback,
-                 base::Owned(new GetDocumentsParams(start_changestamp,
-                                                    root_feed_changestamp,
-                                                    feed_list.release(),
-                                                    should_fetch_multiple_feeds,
-                                                    search_file_path,
-                                                    search_query,
-                                                    directory_resource_id,
-                                                    entry_found_callback,
-                                                    NULL)),
-                 start_time));
-}
-
-void GDataWapiFeedLoader::OnFeedFromServerLoaded(GetDocumentsParams* params,
-                                                 GDataFileError error) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
-
-  if (error != GDATA_FILE_OK) {
-    if (!params->callback.is_null())
-      params->callback.Run(error, NULL);
-    return;
-  }
-
-  error = UpdateFromFeed(*params->feed_list,
-                         params->start_changestamp,
-                         params->root_feed_changestamp);
-
-  if (error != GDATA_FILE_OK) {
-    if (!params->callback.is_null())
-      params->callback.Run(error, NULL);
-
-    return;
-  }
-
-  // Save file system metadata to disk.
-  SaveFileSystem();
-
-  // If we had someone to report this too, then this retrieval was done in a
-  // context of search... so continue search.
-  if (!params->callback.is_null()) {
-    directory_service_->FindEntryByPathAndRunSync(params->search_file_path,
-                                                  params->callback);
-  }
-
-  FOR_EACH_OBSERVER(Observer, observers_, OnFeedFromServerLoaded());
-}
-
 void GDataFileSystem::TransferFileFromRemoteToLocal(
     const FilePath& remote_src_file_path,
     const FilePath& local_dest_file_path,
     const FileOperationCallback& callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   GetFileByPath(remote_src_file_path,
       base::Bind(&GDataFileSystem::OnGetFileCompleteForTransferFile,
                  ui_weak_ptr_,
                  local_dest_file_path,
@@ skipping 38 matching lines @@
   if (!entry_proto->file_info().is_directory()) {
     // The parent of |remote_dest_file_path| is not a directory.
     if (!callback.is_null()) {
       base::MessageLoopProxy::current()->PostTask(
           FROM_HERE, base::Bind(callback, GDATA_FILE_ERROR_NOT_A_DIRECTORY));
     }
     return;
   }
 
   std::string* resource_id = new std::string;
-  PostBlockingPoolSequencedTaskAndReply(
+  util::PostBlockingPoolSequencedTaskAndReply(
       FROM_HERE,
       blocking_task_runner_,
       base::Bind(&GetDocumentResourceIdOnBlockingPool,
                  local_src_file_path,
                  resource_id),
       base::Bind(&GDataFileSystem::TransferFileForResourceId,
                  ui_weak_ptr_,
                  local_src_file_path,
                  remote_dest_file_path,
                  callback,
@@ skipping 28 matching lines @@
 void GDataFileSystem::TransferRegularFile(
     const FilePath& local_file_path,
     const FilePath& remote_dest_file_path,
     const FileOperationCallback& callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   GDataFileError* error =
       new GDataFileError(GDATA_FILE_OK);
   int64* file_size = new int64;
   std::string* content_type = new std::string;
-  PostBlockingPoolSequencedTaskAndReply(
+  util::PostBlockingPoolSequencedTaskAndReply(
       FROM_HERE,
       blocking_task_runner_,
       base::Bind(&GetLocalFileInfoOnBlockingPool,
                  local_file_path,
                  error,
                  file_size,
                  content_type),
       base::Bind(&GDataFileSystem::StartFileUploadOnUIThread,
                  ui_weak_ptr_,
                  StartFileUploadParams(local_file_path,
@@ skipping 207 matching lines @@
       callback.Run(error);
 
     return;
   }
 
   // GetFileByPath downloads the file from gdata to a local cache, which is then
   // copied to the actual destination path on the local file system using
   // CopyLocalFileOnBlockingPool.
   GDataFileError* copy_file_error =
       new GDataFileError(GDATA_FILE_OK);
-  PostBlockingPoolSequencedTaskAndReply(
+  util::PostBlockingPoolSequencedTaskAndReply(
       FROM_HERE,
       blocking_task_runner_,
       base::Bind(&CopyLocalFileOnBlockingPool,
                  local_file_path,
                  local_dest_file_path,
                  copy_file_error),
       base::Bind(&RunFileOperationCallbackHelper,
                  callback,
                  base::Owned(copy_file_error)));
 }
@@ skipping 502 matching lines @@
   // For a hosted document, we create a special JSON file to represent the
   // document instead of fetching the document content in one of the exported
   // formats. The JSON file contains the edit URL and resource ID of the
   // document.
   if (entry_proto->file_specific_info().is_hosted_document()) {
     GDataFileError* error =
         new GDataFileError(GDATA_FILE_OK);
     FilePath* temp_file_path = new FilePath;
     std::string* mime_type = new std::string;
     GDataFileType* file_type = new GDataFileType(REGULAR_FILE);
-    PostBlockingPoolSequencedTaskAndReply(
+    util::PostBlockingPoolSequencedTaskAndReply(
         FROM_HERE,
         blocking_task_runner_,
         base::Bind(&CreateDocumentJsonFileOnBlockingPool,
                    cache_->GetCacheDirectoryPath(
                        GDataCache::CACHE_TYPE_TMP_DOCUMENTS),
                    GURL(entry_proto->file_specific_info().alternate_url()),
                    entry_proto->resource_id(),
                    error,
                    temp_file_path,
                    mime_type,
@@ skipping 131 matching lines @@
                                         params.get_file_callback,
                                         params.get_download_data_callback)));
 }
 
 void GDataFileSystem::OnGetDocumentEntry(const FilePath& cache_file_path,
                                          const GetFileFromCacheParams& params,
                                          GDataErrorCode status,
                                          scoped_ptr<base::Value> data) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
-  GDataFileError error = GDataToGDataFileError(status);
+  GDataFileError error = util::GDataToGDataFileError(status);
 
   scoped_ptr<GDataEntry> fresh_entry;
   if (error == GDATA_FILE_OK) {
     scoped_ptr<DocumentEntry> doc_entry(DocumentEntry::ExtractAndParse(*data));
     if (doc_entry.get()) {
       fresh_entry.reset(
           GDataEntry::FromDocumentEntry(NULL, doc_entry.get(),
                                         directory_service_.get()));
     }
     if (!fresh_entry.get() || !fresh_entry->AsGDataFile()) {
@@ skipping 14 matching lines @@
 
   GURL content_url = fresh_entry->content_url();
   int64 file_size = fresh_entry->file_info().size;
 
   DCHECK_EQ(params.resource_id, fresh_entry->resource_id());
   scoped_ptr<GDataFile> fresh_entry_as_file(
       fresh_entry.release()->AsGDataFile());
   directory_service_->RefreshFile(fresh_entry_as_file.Pass());
 
   bool* has_enough_space = new bool(false);
-  PostBlockingPoolSequencedTaskAndReply(
+  util::PostBlockingPoolSequencedTaskAndReply(
       FROM_HERE,
       blocking_task_runner_,
       base::Bind(&GDataCache::FreeDiskSpaceIfNeededFor,
                  base::Unretained(cache_),
                  file_size,
                  has_enough_space),
       base::Bind(&GDataFileSystem::StartDownloadFileIfEnoughSpace,
                  ui_weak_ptr_,
                  params,
                  content_url,
@@ skipping 312 matching lines @@
   if (error != GDATA_FILE_OK) {
     if (!callback.is_null())
       callback.Run(error);
     return;
   }
 
   // Gets the size of the cache file. Since the file is locally modified, the
   // file size information stored in GDataEntry is not correct.
   GDataFileError* get_size_error = new GDataFileError(GDATA_FILE_ERROR_FAILED);
   int64* file_size = new int64(-1);
-  PostBlockingPoolSequencedTaskAndReply(
+  util::PostBlockingPoolSequencedTaskAndReply(
       FROM_HERE,
       blocking_task_runner_,
       base::Bind(&GetLocalFileSizeOnBlockingPool,
                  cache_file_path,
                  get_size_error,
                  file_size),
       base::Bind(&GDataFileSystem::OnGetFileSizeCompleteForUpdateFile,
                  ui_weak_ptr_,
                  callback,
                  resource_id,
@@ skipping 92 matching lines @@
                  ui_weak_ptr_,
                  callback));
 }
 
 void GDataFileSystem::OnGetAvailableSpace(
     const GetAvailableSpaceCallback& callback,
     GDataErrorCode status,
     scoped_ptr<base::Value> data) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
-  GDataFileError error = GDataToGDataFileError(status);
+  GDataFileError error = util::GDataToGDataFileError(status);
   if (error != GDATA_FILE_OK) {
     callback.Run(error, -1, -1);
     return;
   }
 
   scoped_ptr<AccountMetadataFeed> feed;
   if (data.get())
     feed = AccountMetadataFeed::CreateFrom(*data);
   if (!feed.get()) {
     callback.Run(GDATA_FILE_ERROR_FAILED, -1, -1);
     return;
   }
 
   callback.Run(GDATA_FILE_OK,
                feed->quota_bytes_total(),
                feed->quota_bytes_used());
 }
 
 void GDataFileSystem::OnCreateDirectoryCompleted(
     const CreateDirectoryParams& params,
     GDataErrorCode status,
     scoped_ptr<base::Value> data) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
-  GDataFileError error = GDataToGDataFileError(status);
+  GDataFileError error = util::GDataToGDataFileError(status);
   if (error != GDATA_FILE_OK) {
     if (!params.callback.is_null())
       params.callback.Run(error);
 
     return;
   }
 
   base::DictionaryValue* dict_value = NULL;
   base::Value* created_entry = NULL;
   if (data.get() && data->GetAsDictionary(&dict_value) && dict_value)
@@ skipping 121 matching lines @@
       // chunk to avoid displaying huge number of search
       // results (especially since we don't cache them).
       FilePath(),  // Not used.
       search_query,
       next_feed,
       std::string(),  // No directory resource ID.
       FindEntryCallback(),  // Not used.
       base::Bind(&GDataFileSystem::OnSearch, ui_weak_ptr_, callback));
 }
 
-void GDataWapiFeedLoader::OnGetDocuments(
-    ContentOrigin initial_origin,
-    const LoadDocumentFeedCallback& callback,
-    GetDocumentsParams* params,
-    base::TimeTicks start_time,
-    GDataErrorCode status,
-    scoped_ptr<base::Value> data) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
-
-  if (params->feed_list->empty()) {
-    UMA_HISTOGRAM_TIMES("Gdata.InitialFeedLoadTime",
-                        base::TimeTicks::Now() - start_time);
-  }
-
-  GDataFileError error = GDataToGDataFileError(status);
-  if (error == GDATA_FILE_OK &&
-      (!data.get() || data->GetType() != Value::TYPE_DICTIONARY)) {
-    error = GDATA_FILE_ERROR_FAILED;
-  }
-
-  if (error != GDATA_FILE_OK) {
-    directory_service_->set_origin(initial_origin);
-
-    if (!callback.is_null())
-      callback.Run(params, error);
-
-    return;
-  }
-
-  GURL next_feed_url;
-  scoped_ptr<DocumentFeed> current_feed(DocumentFeed::ExtractAndParse(*data));
-  if (!current_feed.get()) {
-    if (!callback.is_null()) {
-      callback.Run(params, GDATA_FILE_ERROR_FAILED);
-    }
-
-    return;
-  }
-  const bool has_next_feed_url = current_feed->GetNextFeedURL(&next_feed_url);
-
-#ifndef NDEBUG
-  // Save initial root feed for analysis.
-  std::string file_name =
-      base::StringPrintf("DEBUG_feed_%d.json",
-                         params->start_changestamp);
-  PostBlockingPoolSequencedTask(
-      FROM_HERE,
-      blocking_task_runner_,
-      base::Bind(&SaveFeedOnBlockingPoolForDebugging,
-                 cache_->GetCacheDirectoryPath(
-                     GDataCache::CACHE_TYPE_META).Append(file_name),
-                 base::Passed(&data)));
-#endif
-
-  // Add the current feed to the list of collected feeds for this directory.
-  params->feed_list->push_back(current_feed.release());
-
-  // Compute and notify the number of entries fetched so far.
-  int num_accumulated_entries = 0;
-  for (size_t i = 0; i < params->feed_list->size(); ++i)
-    num_accumulated_entries += params->feed_list->at(i)->entries().size();
-
-  // Check if we need to collect more data to complete the directory list.
-  if (params->should_fetch_multiple_feeds && has_next_feed_url &&
-      !next_feed_url.is_empty()) {
-    // Post an UI update event to make the UI smoother.
-    GetDocumentsUiState* ui_state = params->ui_state.get();
-    if (ui_state == NULL) {
-      ui_state = new GetDocumentsUiState(base::TimeTicks::Now());
-      params->ui_state.reset(ui_state);
-    }
-    DCHECK(ui_state);
-
-    if ((ui_state->num_fetched_documents - ui_state->num_showing_documents)
-        < kFetchUiUpdateStep) {
-      // Currently the UI update is stopped. Start UI periodic callback.
-      MessageLoop::current()->PostTask(
-          FROM_HERE,
-          base::Bind(&GDataWapiFeedLoader::OnNotifyDocumentFeedFetched,
-                     weak_ptr_factory_.GetWeakPtr(),
-                     ui_state->weak_ptr_factory.GetWeakPtr()));
-    }
-    ui_state->num_fetched_documents = num_accumulated_entries;
-    ui_state->feed_fetching_elapsed_time = base::TimeTicks::Now() - start_time;
-
-    // Kick of the remaining part of the feeds.
-    documents_service_->GetDocuments(
-        next_feed_url,
-        params->start_changestamp,
-        params->search_query,
-        params->directory_resource_id,
-        base::Bind(&GDataWapiFeedLoader::OnGetDocuments,
-                   weak_ptr_factory_.GetWeakPtr(),
-                   initial_origin,
-                   callback,
-                   base::Owned(
-                       new GetDocumentsParams(
-                           params->start_changestamp,
-                           params->root_feed_changestamp,
-                           params->feed_list.release(),
-                           params->should_fetch_multiple_feeds,
-                           params->search_file_path,
-                           params->search_query,
-                           params->directory_resource_id,
-                           params->callback,
-                           params->ui_state.release())),
-                   start_time));
-    return;
-  }
-
-  // Notify the observers that a document feed is fetched.
-  FOR_EACH_OBSERVER(Observer, observers_,
-                    OnDocumentFeedFetched(num_accumulated_entries));
-
-  UMA_HISTOGRAM_TIMES("Gdata.EntireFeedLoadTime",
-                      base::TimeTicks::Now() - start_time);
-
-  if (!callback.is_null())
-    callback.Run(params, error);
-}
-
-void GDataWapiFeedLoader::OnNotifyDocumentFeedFetched(
-    base::WeakPtr<GetDocumentsUiState> ui_state) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
-
-  if (!ui_state) {
-    // The ui state instance is already released, which means the fetching
-    // is done and we don't need to update any more.
-    return;
-  }
-
-  base::TimeDelta elapsed_time =
-      base::TimeTicks::Now() - ui_state->start_time;
-
-  if (ui_state->num_showing_documents + kFetchUiUpdateStep <=
-      ui_state->num_fetched_documents) {
-    ui_state->num_showing_documents += kFetchUiUpdateStep;
-    FOR_EACH_OBSERVER(Observer, observers_,
-                      OnDocumentFeedFetched(ui_state->num_showing_documents));
-
-    int num_remaining_ui_updates =
-        (ui_state->num_fetched_documents - ui_state->num_showing_documents)
-        / kFetchUiUpdateStep;
-    if (num_remaining_ui_updates > 0) {
-      // Heuristically, we use fetched time duration to calculate the next
-      // UI update timing.
-      base::TimeDelta remaining_duration =
-          ui_state->feed_fetching_elapsed_time - elapsed_time;
-      MessageLoop::current()->PostDelayedTask(
-          FROM_HERE,
-          base::Bind(&GDataWapiFeedLoader::OnNotifyDocumentFeedFetched,
-                     weak_ptr_factory_.GetWeakPtr(),
-                     ui_state->weak_ptr_factory.GetWeakPtr()),
-          remaining_duration / num_remaining_ui_updates);
-    }
-  }
-}
-
-void GDataWapiFeedLoader::LoadFromCache(
-    bool should_load_from_server,
-    const FilePath& search_file_path,
-    const FindEntryCallback& callback) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
-
-  LoadRootFeedParams* params = new LoadRootFeedParams(search_file_path,
-                                                      should_load_from_server,
-                                                      callback);
-  FilePath path = cache_->GetCacheDirectoryPath(GDataCache::CACHE_TYPE_META);
-  if (UseLevelDB()) {
-    path = path.Append(kResourceMetadataDBFile);
-    directory_service_->InitFromDB(path, blocking_task_runner_,
-        base::Bind(
-            &GDataWapiFeedLoader::ContinueWithInitializedDirectoryService,
-            weak_ptr_factory_.GetWeakPtr(),
-            base::Owned(params)));
-  } else {
-    path = path.Append(kFilesystemProtoFile);
-    BrowserThread::GetBlockingPool()->PostTaskAndReply(FROM_HERE,
-        base::Bind(&LoadProtoOnBlockingPool, path, params),
-        base::Bind(&GDataWapiFeedLoader::OnProtoLoaded,
-                   weak_ptr_factory_.GetWeakPtr(),
-                   base::Owned(params)));
-  }
-}
-
 void GDataFileSystem::OnDirectoryChanged(const FilePath& directory_path) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   FOR_EACH_OBSERVER(GDataFileSystemInterface::Observer, observers_,
                     OnDirectoryChanged(directory_path));
 }
 
 void GDataFileSystem::OnDocumentFeedFetched(int num_accumulated_entries) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
@@ skipping 22 matching lines @@
     const std::vector<DocumentFeed*>& feed_list,
     int start_changestamp,
     int root_feed_changestamp) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   return feed_loader_->UpdateFromFeed(feed_list,
                                       start_changestamp,
                                       root_feed_changestamp);
 }
 
-void GDataWapiFeedLoader::OnProtoLoaded(LoadRootFeedParams* params) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
-
-  // If we have already received updates from the server, bail out.
-  if (directory_service_->origin() == FROM_SERVER)
-    return;
-
-  // Update directory structure only if everything is OK and we haven't yet
-  // received the feed from the server yet.
-  if (params->load_error == GDATA_FILE_OK) {
-    DVLOG(1) << "ParseFromString";
-    if (directory_service_->ParseFromString(params->proto)) {
-      directory_service_->set_last_serialized(params->last_modified);
-      directory_service_->set_serialized_size(params->proto.size());
-    } else {
-      params->load_error = GDATA_FILE_ERROR_FAILED;
-      LOG(WARNING) << "Parse of cached proto file failed";
-    }
-  }
-
-  ContinueWithInitializedDirectoryService(params, params->load_error);
-}
-
-void GDataWapiFeedLoader::ContinueWithInitializedDirectoryService(
-    LoadRootFeedParams* params,
-    GDataFileError error) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
-
-  DVLOG(1) << "Time elapsed to load directory service from disk="
-           << (base::Time::Now() - params->load_start_time).InMilliseconds()
-           << " milliseconds";
-
-  FindEntryCallback callback = params->callback;
-  // If we got feed content from cache, try search over it.
-  if (error == GDATA_FILE_OK && !callback.is_null()) {
-    // Continue file content search operation if the delegate hasn't terminated
-    // this search branch already.
-    directory_service_->FindEntryByPathAndRunSync(params->search_file_path,
-                                                  callback);
-    callback.Reset();
-  }
-
-  if (!params->should_load_from_server)
-    return;
-
-  // Decide the |initial_origin| to pass to ReloadFromServerIfNeeded().
-  // This is used to restore directory content origin to its initial value when
-  // we fail to retrieve the feed from server.
-  // By default, if directory content is not yet initialized, restore content
-  // origin to UNINITIALIZED in case of failure.
-  ContentOrigin initial_origin = UNINITIALIZED;
-  if (directory_service_->origin() != INITIALIZING) {
-    // If directory content is already initialized, restore content origin
-    // to FROM_CACHE in case of failure.
-    initial_origin = FROM_CACHE;
-    directory_service_->set_origin(REFRESHING);
-  }
-
-  // Kick of the retrieval of the feed from server. If we have previously
-  // |reported| to the original callback, then we just need to refresh the
-  // content without continuing search upon operation completion.
-  ReloadFromServerIfNeeded(initial_origin,
-                           directory_service_->largest_changestamp(),
-                           params->search_file_path,
-                           callback);
-}
-
-void GDataWapiFeedLoader::SaveFileSystem() {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
-
-  if (!ShouldSerializeFileSystemNow(directory_service_->serialized_size(),
-                                    directory_service_->last_serialized())) {
-    return;
-  }
-
-  if (UseLevelDB()) {
-    directory_service_->SaveToDB();
-  } else {
-    const FilePath path =
-        cache_->GetCacheDirectoryPath(GDataCache::CACHE_TYPE_META).Append(
-            kFilesystemProtoFile);
-    scoped_ptr<std::string> serialized_proto(new std::string());
-    directory_service_->SerializeToString(serialized_proto.get());
-    directory_service_->set_last_serialized(base::Time::Now());
-    directory_service_->set_serialized_size(serialized_proto->size());
-    PostBlockingPoolSequencedTask(
-        FROM_HERE,
-        blocking_task_runner_,
-        base::Bind(&SaveProtoOnBlockingPool, path,
-                   base::Passed(serialized_proto.Pass())));
-  }
-}
-
 void GDataFileSystem::OnFilePathUpdated(const FileOperationCallback& callback,
                                         GDataFileError error,
                                         const FilePath& file_path) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   if (!callback.is_null())
     callback.Run(error);
 }
 
 void GDataFileSystem::OnRenameResourceCompleted(
     const FilePath& file_path,
     const FilePath::StringType& new_name,
     const FilePathUpdateCallback& callback,
     GDataErrorCode status,
     const GURL& document_url) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   FilePath updated_file_path;
-  GDataFileError error = GDataToGDataFileError(status);
+  GDataFileError error = util::GDataToGDataFileError(status);
   if (error == GDATA_FILE_OK)
     error = RenameFileOnFilesystem(file_path, new_name, &updated_file_path);
 
   if (!callback.is_null())
     callback.Run(error, updated_file_path);
 }
 
 void GDataFileSystem::OnCopyDocumentCompleted(
     const FilePath& dir_path,
     const FileOperationCallback& callback,
     GDataErrorCode status,
     scoped_ptr<base::Value> data) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
-  GDataFileError error = GDataToGDataFileError(status);
+  GDataFileError error = util::GDataToGDataFileError(status);
   if (error != GDATA_FILE_OK) {
     if (!callback.is_null())
       callback.Run(error);
 
     return;
   }
 
   scoped_ptr<DocumentEntry> doc_entry(DocumentEntry::ExtractAndParse(*data));
   if (!doc_entry.get()) {
     if (!callback.is_null())
@@ skipping 19 matching lines @@
 }
 
 void GDataFileSystem::OnAddEntryToDirectoryCompleted(
     const FileOperationCallback& callback,
     const FilePath& file_path,
     const FilePath& dir_path,
     GDataErrorCode status,
     const GURL& document_url) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
-  GDataFileError error = GDataToGDataFileError(status);
+  GDataFileError error = util::GDataToGDataFileError(status);
   if (error == GDATA_FILE_OK) {
     GDataEntry* entry = directory_service_->FindEntryByPathSync(file_path);
     if (entry) {
       DCHECK_EQ(directory_service_->root(), entry->parent());
       error = AddEntryToDirectoryOnFilesystem(entry, dir_path);
     } else {
       error = GDATA_FILE_ERROR_NOT_FOUND;
     }
   }
 
   if (!callback.is_null())
     callback.Run(error);
 }
 
 void GDataFileSystem::OnRemoveEntryFromDirectoryCompleted(
     const FilePathUpdateCallback& callback,
     const FilePath& file_path,
     const FilePath& dir_path,
     GDataErrorCode status,
     const GURL& document_url) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   FilePath updated_file_path = file_path;
-  GDataFileError error = GDataToGDataFileError(status);
+  GDataFileError error = util::GDataToGDataFileError(status);
   if (error == GDATA_FILE_OK)
     error = RemoveEntryFromDirectoryOnFilesystem(file_path, dir_path,
                                                  &updated_file_path);
 
   if (!callback.is_null())
     callback.Run(error, updated_file_path);
 }
 
 void GDataFileSystem::OnRemovedDocument(
     const FileOperationCallback& callback,
     const FilePath& file_path,
     GDataErrorCode status,
     const GURL& document_url) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
-  GDataFileError error = GDataToGDataFileError(status);
+  GDataFileError error = util::GDataToGDataFileError(status);
 
   if (error == GDATA_FILE_OK)
     error = RemoveEntryFromFileSystem(file_path);
 
   if (!callback.is_null()) {
     callback.Run(error);
   }
 }
 
 void GDataFileSystem::OnFileDownloaded(
@@ skipping 17 matching lines @@
 
   // At this point, the disk can be full or nearly full for several reasons:
   // - The expected file size was incorrect and the file was larger
   // - There was an in-flight download operation and it used up space
   // - The disk became full for some user actions we cannot control
   //   (ex. the user might have downloaded a large file from a regular web site)
   //
   // If we don't have enough space, we return PLATFORM_FILE_ERROR_NO_SPACE,
   // and try to free up space, even if the file was downloaded successfully.
   bool* has_enough_space = new bool(false);
-  PostBlockingPoolSequencedTaskAndReply(
+  util::PostBlockingPoolSequencedTaskAndReply(
       FROM_HERE,
       blocking_task_runner_,
       base::Bind(&GDataCache::FreeDiskSpaceIfNeededFor,
                  base::Unretained(cache_),
                  0,
                  has_enough_space),
       base::Bind(&GDataFileSystem::OnFileDownloadedAndSpaceChecked,
                  ui_weak_ptr_,
                  params,
                  status,
@@ skipping 15 matching lines @@
 }
 
 void GDataFileSystem::OnFileDownloadedAndSpaceChecked(
     const GetFileFromCacheParams& params,
     GDataErrorCode status,
     const GURL& content_url,
     const FilePath& downloaded_file_path,
     bool* has_enough_space) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
-  GDataFileError error = GDataToGDataFileError(status);
+  GDataFileError error = util::GDataToGDataFileError(status);
 
   // Make sure that downloaded file is properly stored in cache. We don't have
   // to wait for this operation to finish since the user can already use the
   // downloaded file.
   if (error == GDATA_FILE_OK) {
     if (*has_enough_space) {
       cache_->StoreOnUIThread(
           params.resource_id,
           params.md5,
           downloaded_file_path,
           GDataCache::FILE_OPERATION_MOVE,
           base::Bind(&GDataFileSystem::OnDownloadStoredToCache,
                      ui_weak_ptr_));
     } else {
       // If we don't have enough space, remove the downloaded file, and
       // report "no space" error.
-      PostBlockingPoolSequencedTask(
+      util::PostBlockingPoolSequencedTask(
           FROM_HERE,
           blocking_task_runner_,
           base::Bind(base::IgnoreResult(&file_util::Delete),
                      downloaded_file_path,
                      false /* recursive*/));
       error = GDATA_FILE_ERROR_NO_SPACE;
     }
   }
 
   if (!params.get_file_callback.is_null()) {
@@ skipping 100 matching lines @@
   if (error != GDATA_FILE_OK)
     return error;
 
   // If resource_id is not empty, remove its corresponding file from cache.
   if (!resource_id.empty())
     cache_->RemoveOnUIThread(resource_id, CacheOperationCallback());
 
   return GDATA_FILE_OK;
 }
 
-GDataFileError GDataWapiFeedLoader::UpdateFromFeed(
-    const std::vector<DocumentFeed*>& feed_list,
-    int start_changestamp,
-    int root_feed_changestamp) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
-  DVLOG(1) << "Updating directory with a feed";
-
-  std::set<FilePath> changed_dirs;
-
-  GDataWapiFeedProcessor feed_processor(directory_service_);
-  const GDataFileError error = feed_processor.ApplyFeeds(
-      feed_list,
-      start_changestamp,
-      root_feed_changestamp,
-      &changed_dirs);
-
-  // Don't send directory content change notification while performing
-  // the initial content retrieval.
-  const bool should_notify_directory_changed = (start_changestamp != 0);
-  if (should_notify_directory_changed) {
-    for (std::set<FilePath>::iterator dir_iter = changed_dirs.begin();
-        dir_iter != changed_dirs.end(); ++dir_iter) {
-      FOR_EACH_OBSERVER(Observer, observers_,
-                        OnDirectoryChanged(*dir_iter));
-    }
-  }
-
-  return error;
-}
-
-
 // static
 void GDataFileSystem::RemoveStaleEntryOnUpload(const std::string& resource_id,
                                                GDataDirectory* parent_dir,
                                                GDataEntry* existing_entry) {
   if (existing_entry &&
       // This should always match, but just in case.
       existing_entry->parent() == parent_dir) {
     parent_dir->RemoveEntry(existing_entry);
   } else {
     LOG(ERROR) << "Entry for the existing file not found: " << resource_id;
@@ skipping 467 matching lines @@
   if (error != GDATA_FILE_OK) {
     if (!callback.is_null())
       callback.Run(error);
     return;
   }
 
   // Step 3 of CloseFile: Retrieves the (possibly modified) PlatformFileInfo of
   // the cache file.
   base::PlatformFileInfo* file_info = new base::PlatformFileInfo;
   bool* get_file_info_result = new bool(false);
-  PostBlockingPoolSequencedTaskAndReply(
+  util::PostBlockingPoolSequencedTaskAndReply(
       FROM_HERE,
       blocking_task_runner_,
       base::Bind(&GetFileInfoOnBlockingPool,
                  local_cache_path,
                  base::Unretained(file_info),
                  base::Unretained(get_file_info_result)),
       base::Bind(&GDataFileSystem::OnGetModifiedFileInfoCompleteForCloseFile,
                  ui_weak_ptr_,
                  file_path,
                  base::Owned(file_info),
@@ skipping 160 matching lines @@
   // When no dirty cache is found, use the original entry info as is.
   if (error != GDATA_FILE_OK) {
     if (!callback.is_null())
       callback.Run(GDATA_FILE_OK, entry_proto.Pass());
     return;
   }
 
   // If the cache is dirty, obtain the file info from the cache file itself.
   base::PlatformFileInfo* file_info = new base::PlatformFileInfo;
   bool* get_file_info_result = new bool(false);
-  PostBlockingPoolSequencedTaskAndReply(
+  util::PostBlockingPoolSequencedTaskAndReply(
       FROM_HERE,
       blocking_task_runner_,
       base::Bind(&GetFileInfoOnBlockingPool,
                  local_cache_path,
                  base::Unretained(file_info),
                  base::Unretained(get_file_info_result)),
       base::Bind(&GDataFileSystem::CheckLocalModificationAndRunAfterGetFileInfo,
                  ui_weak_ptr_,
                  base::Passed(&entry_proto),
                  callback,
@@ skipping 15 matching lines @@
   }
 
   PlatformFileInfoProto entry_file_info;
   GDataEntry::ConvertPlatformFileInfoToProto(*file_info, &entry_file_info);
   *entry_proto->mutable_file_info() = entry_file_info;
   if (!callback.is_null())
     callback.Run(GDATA_FILE_OK, entry_proto.Pass());
 }
 
 }  // namespace gdata