gdata: Introduce GDataWapiFeedLoader class

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"
@@ skipping 540 matching lines @@
     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
 
-// GDataFileSystem::GetDocumentsParams struct implementation.
-struct GDataFileSystem::GetDocumentsParams {
+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 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);
   ~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;
 };
 
-GDataFileSystem::GetDocumentsParams::GetDocumentsParams(
+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)
     : 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) {
 }
 
-GDataFileSystem::GetDocumentsParams::~GetDocumentsParams() {
+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);
@@ skipping 122 matching lines @@
   // Should be created from the file browser extension API on UI thread.
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 }
 
 void GDataFileSystem::Initialize() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   documents_service_->Initialize(profile_);
 
   directory_service_.reset(new GDataDirectoryService);
+  feed_loader_.reset(new GDataWapiFeedLoader(directory_service_.get(),
+                                             documents_service_,
+                                             webapps_registry_,
+                                             cache_,
+                                             blocking_task_runner_));
+  feed_loader_->AddObserver(this);
 
   PrefService* pref_service = profile_->GetPrefs();
   hide_hosted_docs_ = pref_service->GetBoolean(prefs::kDisableGDataHostedFiles);
 
   InitializePreferenceObserver();
 }
 
 void GDataFileSystem::CheckForUpdates() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   ContentOrigin initial_origin = directory_service_->origin();
   if (initial_origin == FROM_SERVER) {
     directory_service_->set_origin(REFRESHING);
-    ReloadFeedFromServerIfNeeded(
+    feed_loader_->ReloadFromServerIfNeeded(
         initial_origin,
         directory_service_->largest_changestamp(),
         directory_service_->root()->GetFilePath(),
         base::Bind(&GDataFileSystem::OnUpdateChecked,
                    ui_weak_ptr_,
                    initial_origin));
   }
 }
 
 void GDataFileSystem::OnUpdateChecked(ContentOrigin initial_origin,
                                       GDataFileError error,
                                       GDataEntry* /* entry */) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   if (error != GDATA_FILE_OK) {
     directory_service_->set_origin(initial_origin);
   }
 }
 
 GDataFileSystem::~GDataFileSystem() {
   // This should be called from UI thread, from GDataSystemService shutdown.
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
+  feed_loader_->RemoveObserver(this);
+
   // Cancel all the in-flight operations.
   // This asynchronously cancels the URL fetch operations.
   documents_service_->CancelAll();
 }
 
-void GDataFileSystem::AddObserver(Observer* observer) {
+void GDataFileSystem::AddObserver(
+    GDataFileSystemInterface::Observer* observer) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   observers_.AddObserver(observer);
 }
 
-void GDataFileSystem::RemoveObserver(Observer* observer) {
+void GDataFileSystem::RemoveObserver(
+    GDataFileSystemInterface::Observer* observer) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   observers_.RemoveObserver(observer);
 }
 
 void GDataFileSystem::StartUpdates() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   DCHECK(!update_timer_.IsRunning());
   update_timer_.Start(FROM_HERE,
                       base::TimeDelta::FromSeconds(
@@ skipping 62 matching lines @@
         this,
         base::Bind(&GDataFileSystem::FindEntryByPathSyncOnUIThread,
                    ui_weak_ptr_,
                    search_file_path,
                    callback)));
     return;
   } else if (directory_service_->origin() == UNINITIALIZED) {
     // Load root feed from this disk cache. Upon completion, kick off server
     // fetching.
     directory_service_->set_origin(INITIALIZING);
-    LoadRootFeedFromCache(
+    feed_loader_->LoadFromCache(
         true,  // should_load_from_server
         search_file_path,
         // This is the initial load, hence we'll notify when it's done.
         base::Bind(&GDataFileSystem::RunAndNotifyInitialLoadFinished,
                    ui_weak_ptr_,
                    callback));
     return;
   }
 
   // Post a task to the same thread, rather than calling it here, as
   // FindEntryByPath() is asynchronous.
   base::MessageLoopProxy::current()->PostTask(
       FROM_HERE,
       base::Bind(&GDataFileSystem::FindEntryByPathSyncOnUIThread,
                  ui_weak_ptr_,
                  search_file_path,
                  callback));
 }
 
 void GDataFileSystem::FindEntryByPathSyncOnUIThread(
     const FilePath& search_file_path,
     const FindEntryCallback& callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
-  GDataEntry* entry = directory_service_->FindEntryByPathSync(
-      search_file_path);
-  callback.Run(entry ? GDATA_FILE_OK : GDATA_FILE_ERROR_NOT_FOUND, entry);
+  directory_service_->FindEntryByPathAndRunSync(search_file_path, callback);
 }
 
-void GDataFileSystem::ReloadFeedFromServerIfNeeded(
+void GDataWapiFeedLoader::ReloadFromServerIfNeeded(
     ContentOrigin initial_origin,
     int local_changestamp,
     const FilePath& search_file_path,
     const FindEntryCallback& callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   // First fetch the latest changestamp to see if there were any new changes
   // there at all.
   documents_service_->GetAccountMetadata(
-      base::Bind(&GDataFileSystem::OnGetAccountMetadata,
-                 ui_weak_ptr_,
+      base::Bind(&GDataWapiFeedLoader::OnGetAccountMetadata,
+                 weak_ptr_factory_.GetWeakPtr(),
                  initial_origin,
                  local_changestamp,
                  search_file_path,
                  callback));
 }
 
-void GDataFileSystem::OnGetAccountMetadata(
+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.
-    LoadFeedFromServer(initial_origin,
-                       local_changestamp + 1, 0,
-                       true,  /* should_fetch_multiple_feeds */
-                       search_file_path,
-                       std::string() /* no search query */,
-                       std::string() /* no directory resource ID */,
-                       callback,
-                       base::Bind(&GDataFileSystem::OnFeedFromServerLoaded,
-                                  ui_weak_ptr_));
+    LoadFromServer(initial_origin,
+                   local_changestamp + 1, 0,
+                   true,  /* should_fetch_multiple_feeds */
+                   search_file_path,
+                   std::string() /* no search query */,
+                   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()) {
-    LoadFeedFromServer(initial_origin,
-                       local_changestamp + 1, 0,
-                       true,  /* should_fetch_multiple_feeds */
-                       search_file_path,
-                       std::string() /* no search query */,
-                       std::string() /* no directory resource ID */,
-                       callback,
-                       base::Bind(&GDataFileSystem::OnFeedFromServerLoaded,
-                                  ui_weak_ptr_));
+    LoadFromServer(initial_origin,
+                   local_changestamp + 1, 0,
+                   true,  /* should_fetch_multiple_feeds */
+                   search_file_path,
+                   std::string() /* no search query */,
+                   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())
-      FindEntryByPathSyncOnUIThread(search_file_path, callback);
+    if (!callback.is_null()) {
+      directory_service_->FindEntryByPathAndRunSync(search_file_path,
+                                                    callback);
+    }
     return;
   }
 
   // Load changes from the server.
-  LoadFeedFromServer(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 */,
-                     std::string() /* no directory resource ID */,
-                     callback,
-                     base::Bind(&GDataFileSystem::OnFeedFromServerLoaded,
-                                ui_weak_ptr_));
+  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 */,
+                 std::string() /* no directory resource ID */,
+                 callback,
+                 base::Bind(&GDataWapiFeedLoader::OnFeedFromServerLoaded,
+                            weak_ptr_factory_.GetWeakPtr()));
 }
 
-void GDataFileSystem::LoadFeedFromServer(
+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 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(
       GURL(),   // root feed start.
       start_changestamp,
       search_query,
       directory_resource_id,
-      base::Bind(&GDataFileSystem::OnGetDocuments,
-                 ui_weak_ptr_,
+      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)),
                  start_time));
 }
 
-void GDataFileSystem::OnFeedFromServerLoaded(GetDocumentsParams* params,
-                                             GDataFileError error) {
+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.
   SaveFileSystemAsProto();
 
   // 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())
-    FindEntryByPathSyncOnUIThread(params->search_file_path, params->callback);
+  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));
 
@@ skipping 1215 matching lines @@
     GDataFileError error,
     scoped_ptr<GDataEntryProto> entry_proto) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   if (error != GDATA_FILE_OK ||
       !entry_proto->file_info().is_directory()) {
     LOG(ERROR) << "Directory entry not found: " << file_path.value();
     return;
   }
 
-  LoadFeedFromServer(directory_service_->origin(),
-                     0,  // Not delta feed.
-                     0,  // Not used.
-                     true,  // multiple feeds
-                     file_path,
-                     std::string(),  // No search query
-                     entry_proto->resource_id(),
-                     FindEntryCallback(),  // Not used.
-                     base::Bind(&GDataFileSystem::OnRequestDirectoryRefresh,
-                                ui_weak_ptr_));
+  feed_loader_->LoadFromServer(
+      directory_service_->origin(),
+      0,  // Not delta feed.
+      0,  // Not used.
+      true,  // multiple feeds
+      file_path,
+      std::string(),  // No search query
+      entry_proto->resource_id(),
+      FindEntryCallback(),  // Not used.
+      base::Bind(&GDataFileSystem::OnRequestDirectoryRefresh,
+                 ui_weak_ptr_));
 }
 
 void GDataFileSystem::OnRequestDirectoryRefresh(
     GetDocumentsParams* params,
     GDataFileError error) {
   DCHECK(params);
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   const FilePath& directory_path = params->search_file_path;
   if (error != GDATA_FILE_OK) {
@@ skipping 47 matching lines @@
     scoped_ptr<GDataEntry> entry(it->second);
     // Skip if it's not a file (i.e. directory).
     if (!entry->AsGDataFile())
       continue;
     directory->AddEntry(entry.release());
   }
 
   // Note that there may be no change in the directory, but it's expensive to
   // check if the new metadata matches the existing one, so we just always
   // notify that the directory is changed.
-  FOR_EACH_OBSERVER(Observer, observers_, OnDirectoryChanged(directory_path));
+  FOR_EACH_OBSERVER(GDataFileSystemInterface::Observer,
+                    observers_, OnDirectoryChanged(directory_path));
   DVLOG(1) << "Directory refreshed: " << directory_path.value();
 }
 
 void GDataFileSystem::UpdateFileByResourceId(
     const std::string& resource_id,
     const FileOperationCallback& callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI) ||
          BrowserThread::CurrentlyOn(BrowserThread::IO));
   RunTaskOnUIThread(
       base::Bind(&GDataFileSystem::UpdateFileByResourceIdOnUIThread,
@@ skipping 303 matching lines @@
 }
 
 void GDataFileSystem::SearchAsyncOnUIThread(
     const std::string& search_query,
     const SearchCallback& callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   scoped_ptr<std::vector<DocumentFeed*> > feed_list(
       new std::vector<DocumentFeed*>);
 
   ContentOrigin initial_origin = directory_service_->origin();
-  LoadFeedFromServer(initial_origin,
-                     0, 0,  // We don't use change stamps when fetching search
-                            // data; we always fetch the whole result feed.
-                     false,  // Stop fetching search results after first feed
-                             // chunk to avoid displaying huge number of search
-                             // results (especially since we don't cache them).
-                     FilePath(),  // Not used.
-                     search_query,
-                     std::string(),  // No directory resource ID.
-                     FindEntryCallback(),  // Not used.
-                     base::Bind(&GDataFileSystem::OnSearch,
-                                ui_weak_ptr_, callback));
+  feed_loader_->LoadFromServer(
+      initial_origin,
+      0, 0,  // We don't use change stamps when fetching search
+      // data; we always fetch the whole result feed.
+      false,  // Stop fetching search results after first feed
+      // chunk to avoid displaying huge number of search
+      // results (especially since we don't cache them).
+      FilePath(),  // Not used.
+      search_query,
+      std::string(),  // No directory resource ID.
+      FindEntryCallback(),  // Not used.
+      base::Bind(&GDataFileSystem::OnSearch, ui_weak_ptr_, callback));
 }
 
-void GDataFileSystem::OnGetDocuments(ContentOrigin initial_origin,
-                                     const LoadDocumentFeedCallback& callback,
-                                     GetDocumentsParams* params,
-                                     base::TimeTicks start_time,
-                                     GDataErrorCode status,
-                                     scoped_ptr<base::Value> data) {
+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)) {
@@ skipping 48 matching lines @@
 
   // 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()) {
     // 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(&GDataFileSystem::OnGetDocuments,
-                   ui_weak_ptr_,
+        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)),
                    start_time));
     return;
   }
 
   UMA_HISTOGRAM_TIMES("Gdata.EntireFeedLoadTime",
                       base::TimeTicks::Now() - start_time);
 
   if (!callback.is_null())
     callback.Run(params, error);
 }
 
-void GDataFileSystem::LoadRootFeedFromCache(
+void GDataWapiFeedLoader::LoadFromCache(
     bool should_load_from_server,
     const FilePath& search_file_path,
     const FindEntryCallback& callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   const FilePath path =
       cache_->GetCacheDirectoryPath(GDataCache::CACHE_TYPE_META).Append(
           kFilesystemProtoFile);
   LoadRootFeedParams* params = new LoadRootFeedParams(search_file_path,
                                                       should_load_from_server,
                                                       callback);
   BrowserThread::GetBlockingPool()->PostTaskAndReply(FROM_HERE,
       base::Bind(&LoadProtoOnBlockingPool, path, params),
-      base::Bind(&GDataFileSystem::OnProtoLoaded,
-                 ui_weak_ptr_,
+      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));
+
+  FOR_EACH_OBSERVER(GDataFileSystemInterface::Observer, observers_,
+                    OnDocumentFeedFetched(num_accumulated_entries));
+}
+
+void GDataFileSystem::OnFeedFromServerLoaded() {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+
+  FOR_EACH_OBSERVER(GDataFileSystemInterface::Observer, observers_,
+                    OnFeedFromServerLoaded());
+}
+
 void GDataFileSystem::LoadRootFeedFromCacheForTesting() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
-  LoadRootFeedFromCache(
+  feed_loader_->LoadFromCache(
       false,  // should_load_from_server.
       // search_path doesn't matter if FindEntryCallback parameter is null .
       FilePath(),
       FindEntryCallback());
 }
 
-void GDataFileSystem::OnProtoLoaded(LoadRootFeedParams* params) {
+GDataFileError GDataFileSystem::UpdateFromFeedForTesting(
+    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;
 
   int local_changestamp = 0;
   // 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());
       local_changestamp = directory_service_->largest_changestamp();
     } else {
       params->load_error = GDATA_FILE_ERROR_FAILED;
       LOG(WARNING) << "Parse of cached proto file failed";
     }
   }
 
   FindEntryCallback callback = params->callback;
   // If we got feed content from cache, try search over it.
   if (params->load_error == GDATA_FILE_OK && !callback.is_null()) {
     // Continue file content search operation if the delegate hasn't terminated
     // this search branch already.
-    FindEntryByPathSyncOnUIThread(params->search_file_path, callback);
+    directory_service_->FindEntryByPathAndRunSync(params->search_file_path,
+                                                  callback);
     callback.Reset();
   }
 
   if (!params->should_load_from_server)
     return;
 
-  // Decide the |initial_origin| to pass to ReloadFeedFromServerIfNeeded().
+  // 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.
-  ReloadFeedFromServerIfNeeded(initial_origin,
-                               local_changestamp,
-                               params->search_file_path,
-                               callback);
+  ReloadFromServerIfNeeded(initial_origin,
+                           local_changestamp,
+                           params->search_file_path,
+                           callback);
 }
 
-void GDataFileSystem::SaveFileSystemAsProto() {
+void GDataWapiFeedLoader::SaveFileSystemAsProto() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   DVLOG(1) << "SaveFileSystemAsProto";
 
   if (!ShouldSerializeFileSystemNow(directory_service_->serialized_size(),
                                     directory_service_->last_serialized())) {
     return;
   }
 
   const FilePath path =
@@ skipping 256 matching lines @@
   // through the file name de-duplication.
   // TODO(achuith/satorux/zel): This code is fragile. The title has been
   // changed, but not the file_name. TakeEntry removes the child based on the
   // old file_name, and then re-adds the child by first assigning the new title
   // to file_name. http://crbug.com/30157
   if (!entry->parent()->TakeEntry(entry))
     return GDATA_FILE_ERROR_FAILED;
 
   *updated_file_path = entry->GetFilePath();
 
-  FOR_EACH_OBSERVER(Observer, observers_,
+  FOR_EACH_OBSERVER(GDataFileSystemInterface::Observer, observers_,
                     OnDirectoryChanged(updated_file_path->DirName()));
   return GDATA_FILE_OK;
 }
 
 GDataFileError GDataFileSystem::AddEntryToDirectoryOnFilesystem(
     GDataEntry* entry, const FilePath& dir_path) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK(entry);
 
   GDataEntry* dir_entry = directory_service_->FindEntryByPathSync(dir_path);
   if (!dir_entry)
     return GDATA_FILE_ERROR_NOT_FOUND;
 
   GDataDirectory* dir = dir_entry->AsGDataDirectory();
   if (!dir)
     return GDATA_FILE_ERROR_NOT_A_DIRECTORY;
 
   if (!dir->TakeEntry(entry))
     return GDATA_FILE_ERROR_FAILED;
 
-  FOR_EACH_OBSERVER(Observer, observers_, OnDirectoryChanged(dir_path));
+  FOR_EACH_OBSERVER(GDataFileSystemInterface::Observer, observers_,
+                    OnDirectoryChanged(dir_path));
   return GDATA_FILE_OK;
 }
 
 GDataFileError GDataFileSystem::RemoveEntryFromDirectoryOnFilesystem(
     const FilePath& file_path, const FilePath& dir_path,
     FilePath* updated_file_path) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK(updated_file_path);
 
   GDataEntry* entry = directory_service_->FindEntryByPathSync(file_path);
   if (!entry)
     return GDATA_FILE_ERROR_NOT_FOUND;
 
   GDataEntry* dir = directory_service_->FindEntryByPathSync(dir_path);
   if (!dir)
     return GDATA_FILE_ERROR_NOT_FOUND;
 
   if (!dir->AsGDataDirectory())
     return GDATA_FILE_ERROR_NOT_A_DIRECTORY;
 
   DCHECK_EQ(dir->AsGDataDirectory(), entry->parent());
 
   if (!directory_service_->root()->TakeEntry(entry))
     return GDATA_FILE_ERROR_FAILED;
 
   *updated_file_path = entry->GetFilePath();
 
-  FOR_EACH_OBSERVER(Observer, observers_,
+  FOR_EACH_OBSERVER(GDataFileSystemInterface::Observer, observers_,
                     OnDirectoryChanged(updated_file_path->DirName()));
   return GDATA_FILE_OK;
 }
 
 GDataFileError GDataFileSystem::RemoveEntryFromFileSystem(
     const FilePath& file_path) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   std::string resource_id;
   GDataFileError error = RemoveEntryFromGData(file_path, &resource_id);
   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 GDataFileSystem::UpdateFromFeed(
+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_.get());
+  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));
+      FOR_EACH_OBSERVER(Observer, observers_,
+                        OnDirectoryChanged(*dir_iter));
     }
   }
 
   return error;
 }
 
 
 // static
 void GDataFileSystem::RemoveStaleEntryOnUpload(const std::string& resource_id,
                                                GDataDirectory* parent_dir,
@@ skipping 11 matching lines @@
     const FindEntryCallback& callback,
     GDataFileError error,
     GDataEntry* entry) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   DVLOG(1) << "Initial load finished";
   if (!callback.is_null())
     callback.Run(error, entry);
 
   // Notify the observers that root directory has been initialized.
-  FOR_EACH_OBSERVER(Observer, observers_, OnInitialLoadFinished());
+  FOR_EACH_OBSERVER(GDataFileSystemInterface::Observer, observers_,
+                    OnInitialLoadFinished());
 }
 
 GDataFileError GDataFileSystem::AddNewDirectory(
     const FilePath& directory_path, base::Value* entry_value) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   if (!entry_value)
     return GDATA_FILE_ERROR_FAILED;
 
   scoped_ptr<DocumentEntry> doc_entry(DocumentEntry::CreateFrom(*entry_value));
@@ skipping 13 matching lines @@
   if (!parent_dir)
     return GDATA_FILE_ERROR_FAILED;
 
   GDataEntry* new_entry = GDataEntry::FromDocumentEntry(
       parent_dir, doc_entry.get(), directory_service_.get());
   if (!new_entry)
     return GDATA_FILE_ERROR_FAILED;
 
   parent_dir->AddEntry(new_entry);
 
-  FOR_EACH_OBSERVER(Observer, observers_, OnDirectoryChanged(directory_path));
+  FOR_EACH_OBSERVER(GDataFileSystemInterface::Observer, observers_,
+                    OnDirectoryChanged(directory_path));
   return GDATA_FILE_OK;
 }
 
 GDataFileSystem::FindMissingDirectoryResult
 GDataFileSystem::FindFirstMissingParentDirectory(
     const FilePath& directory_path,
     GURL* last_dir_content_url,
     FilePath* first_missing_parent_path) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
@@ skipping 41 matching lines @@
 
   // If it's a file (only files have resource id), get its resource id so that
   // we can remove it after releasing the auto lock.
   if (entry->AsGDataFile())
     *resource_id = entry->AsGDataFile()->resource_id();
 
   GDataDirectory* parent_dir = entry->parent();
   if (!parent_dir->RemoveEntry(entry))
     return GDATA_FILE_ERROR_NOT_FOUND;
 
-  FOR_EACH_OBSERVER(Observer, observers_,
+  FOR_EACH_OBSERVER(GDataFileSystemInterface::Observer, observers_,
                     OnDirectoryChanged(parent_dir->GetFilePath()));
   return GDATA_FILE_OK;
 }
 
 void GDataFileSystem::AddUploadedFile(
     UploadMode upload_mode,
     const FilePath& virtual_dir_path,
     scoped_ptr<DocumentEntry> entry,
     const FilePath& file_content_path,
     GDataCache::FileOperationType cache_operation,
@@ skipping 57 matching lines @@
     directory_service_->GetEntryByResourceIdAsync(resource_id,
         base::Bind(&RemoveStaleEntryOnUpload, resource_id, parent_dir));
   }
 
   GDataFile* file = new_entry->AsGDataFile();
   DCHECK(file);
   const std::string& resource_id = file->resource_id();
   const std::string& md5 = file->file_md5();
   parent_dir->AddEntry(new_entry.release());
 
-  FOR_EACH_OBSERVER(Observer, observers_,
+  FOR_EACH_OBSERVER(GDataFileSystemInterface::Observer, observers_,
                     OnDirectoryChanged(virtual_dir_path));
 
   if (upload_mode == UPLOAD_NEW_FILE) {
     // Add the file to the cache if we have uploaded a new file.
     cache_->StoreOnUIThread(resource_id,
                             md5,
                             file_content_path,
                             cache_operation,
                             base::Bind(&OnCacheUpdatedForAddUploadedFile,
                                        callback));
@@ skipping 28 matching lines @@
 void GDataFileSystem::SetHideHostedDocuments(bool hide) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   if (hide == hide_hosted_docs_)
     return;
 
   hide_hosted_docs_ = hide;
   const FilePath root_path = directory_service_->root()->GetFilePath();
 
   // Kick off directory refresh when this setting changes.
-  FOR_EACH_OBSERVER(Observer, observers_, OnDirectoryChanged(root_path));
+  FOR_EACH_OBSERVER(GDataFileSystemInterface::Observer, observers_,
+                    OnDirectoryChanged(root_path));
 }
 
 //============= GDataFileSystem: internal helper functions =====================
 
 void GDataFileSystem::InitializePreferenceObserver() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   pref_registrar_.reset(new PrefChangeRegistrar());
   pref_registrar_->Init(profile_->GetPrefs());
   pref_registrar_->Add(prefs::kDisableGDataHostedFiles, this);
@@ skipping 418 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