drive: Rename 'gdata' namespace to 'drive' in chrome/browser/chromeos/drive

chrome/browser/chromeos/drive/gdata_wapi_feed_loader.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/drive/gdata_wapi_feed_loader.h"
 
 #include <set>
 
 #include "base/command_line.h"
 #include "base/file_util.h"
@@ skipping 10 matching lines @@
 #include "chrome/browser/chromeos/drive/drive_webapps_registry.h"
 #include "chrome/browser/chromeos/drive/gdata_wapi_feed_loader_observer.h"
 #include "chrome/browser/chromeos/drive/gdata_wapi_feed_processor.h"
 #include "chrome/browser/google_apis/drive_api_parser.h"
 #include "chrome/browser/google_apis/gdata_util.h"
 #include "chrome/common/chrome_switches.h"
 #include "content/public/browser/browser_thread.h"
 
 using content::BrowserThread;
 
-namespace gdata {
+namespace drive {
 
 namespace {
 
 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");
 
@@ skipping 99 matching lines @@
 
 // Run params->feed_load_callback with |error|.
 void RunFeedLoadCallback(scoped_ptr<LoadFeedParams> params,
                          DriveFileError error) {
   // Need a reference before calling Pass().
   const LoadDocumentFeedCallback& feed_load_callback =
       params->feed_load_callback;
   feed_load_callback.Run(params.Pass(), error);
 }
 
-// Parses a DocumentFeed from |data|.
+// Parses a gdata::DocumentFeed from |data|.
 void ParseFeedOnBlockingPool(
     scoped_ptr<base::Value> data,
-    scoped_ptr<DocumentFeed>* out_current_feed) {
+    scoped_ptr<gdata::DocumentFeed>* out_current_feed) {
   DCHECK(out_current_feed);
-  out_current_feed->reset(DocumentFeed::ExtractAndParse(*data).release());
+  out_current_feed->reset(
+      gdata::DocumentFeed::ExtractAndParse(*data).release());
 }
 
 }  // namespace
 
 LoadFeedParams::LoadFeedParams(
     ContentOrigin initial_origin,
     const LoadDocumentFeedCallback& feed_load_callback)
     : initial_origin(initial_origin),
       start_changestamp(0),
       root_feed_changestamp(0),
@@ skipping 106 matching lines @@
                  weak_ptr_factory_.GetWeakPtr(),
                  initial_origin,
                  local_changestamp,
                  callback));
 }
 
 void GDataWapiFeedLoader::OnGetAccountMetadata(
     ContentOrigin initial_origin,
     int64 local_changestamp,
     const FileOperationCallback& callback,
-    GDataErrorCode status,
+    gdata::GDataErrorCode status,
     scoped_ptr<base::Value> feed_data) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   scoped_ptr<LoadFeedParams> params(new LoadFeedParams(
       initial_origin,
       base::Bind(&GDataWapiFeedLoader::OnFeedFromServerLoaded,
                  weak_ptr_factory_.GetWeakPtr())));
   params->start_changestamp = local_changestamp + 1;
   params->load_finished_callback = callback;
 
   DriveFileError error = util::GDataToDriveFileError(status);
   if (error != DRIVE_FILE_OK) {
     // Get changes starting from the next changestamp from what we have locally.
     LoadFromServer(params.Pass());
     return;
   }
 
-  scoped_ptr<AccountMetadataFeed> account_metadata;
+  scoped_ptr<gdata::AccountMetadataFeed> account_metadata;
   if (feed_data.get()) {
-    account_metadata = AccountMetadataFeed::CreateFrom(*feed_data);
+    account_metadata = gdata::AccountMetadataFeed::CreateFrom(*feed_data);
 #ifndef NDEBUG
     // Save account metadata feed for analysis.
     const FilePath path =
         cache_->GetCacheDirectoryPath(DriveCache::CACHE_TYPE_META).Append(
             kAccountMetadataFile);
-    util::PostBlockingPoolSequencedTask(
+    gdata::util::PostBlockingPoolSequencedTask(
         FROM_HERE,
         blocking_task_runner_,
         base::Bind(&SaveFeedOnBlockingPoolForDebugging,
                    path, base::Passed(&feed_data)));
 #endif
   }
 
   if (!account_metadata.get()) {
     LoadFromServer(params.Pass());
     return;
@@ skipping 26 matching lines @@
   // Load changes from the server.
   params->start_changestamp = local_changestamp > 0 ? local_changestamp + 1 : 0;
   params->root_feed_changestamp = account_metadata->largest_changestamp();
   LoadFromServer(params.Pass());
 }
 
 void GDataWapiFeedLoader::OnGetAboutResource(
     ContentOrigin initial_origin,
     int64 local_changestamp,
     const FileOperationCallback& callback,
-    GDataErrorCode status,
+    gdata::GDataErrorCode status,
     scoped_ptr<base::Value> feed_data) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   scoped_ptr<LoadFeedParams> params(new LoadFeedParams(
       initial_origin,
       base::Bind(&GDataWapiFeedLoader::OnFeedFromServerLoaded,
                  weak_ptr_factory_.GetWeakPtr())));
   params->load_finished_callback = callback;
 
   DriveFileError error = util::GDataToDriveFileError(status);
   if (error != DRIVE_FILE_OK) {
     // Get changes starting from the next changestamp from what we have locally.
     LoadFromServer(params.Pass());
     return;
   }
 
-  scoped_ptr<AboutResource> about_resource;
+  scoped_ptr<gdata::AboutResource> about_resource;
   if (feed_data.get())
-    about_resource = AboutResource::CreateFrom(*feed_data);
+    about_resource = gdata::AboutResource::CreateFrom(*feed_data);
 
   if (!about_resource.get()) {
     LoadFromServer(params.Pass());
     return;
   }
 
   bool changes_detected = true;
   int64 largest_changestamp = about_resource->largest_change_id();
   resource_metadata_->InitializeRootEntry(about_resource->root_folder_id());
 
@@ skipping 18 matching lines @@
     return;
   }
 
   // Load changes from the server.
   params->start_changestamp = local_changestamp > 0 ? local_changestamp + 1 : 0;
   params->root_feed_changestamp = largest_changestamp;
   LoadFromServer(params.Pass());
 }
 
 void GDataWapiFeedLoader::OnGetApplicationList(
-    GDataErrorCode status,
+    gdata::GDataErrorCode status,
     scoped_ptr<base::Value> json) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   DriveFileError error = util::GDataToDriveFileError(status);
   if (error != DRIVE_FILE_OK)
     return;
 
   if (json.get()) {
-    scoped_ptr<AppList> applist(AppList::CreateFrom(*json));
+    scoped_ptr<gdata::AppList> applist(gdata::AppList::CreateFrom(*json));
     if (applist.get()) {
       VLOG(1) << "applist get success";
       webapps_registry_->UpdateFromApplicationList(*applist.get());
     }
   }
 }
 
 void GDataWapiFeedLoader::LoadFromServer(scoped_ptr<LoadFeedParams> params) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
@@ skipping 77 matching lines @@
     params->load_finished_callback.Run(DRIVE_FILE_OK);
 
   FOR_EACH_OBSERVER(GDataWapiFeedLoaderObserver,
                     observers_,
                     OnFeedFromServerLoaded());
 }
 
 void GDataWapiFeedLoader::OnGetDocuments(
     scoped_ptr<LoadFeedParams> params,
     base::TimeTicks start_time,
-    GDataErrorCode status,
+    gdata::GDataErrorCode status,
     scoped_ptr<base::Value> data) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   if (params->feed_list.empty()) {
     UMA_HISTOGRAM_TIMES("Drive.InitialFeedLoadTime",
                         base::TimeTicks::Now() - start_time);
   }
 
   DriveFileError error = util::GDataToDriveFileError(status);
   if (error == DRIVE_FILE_OK &&
       (!data.get() || data->GetType() != Value::TYPE_DICTIONARY)) {
     error = DRIVE_FILE_ERROR_FAILED;
   }
 
   if (error != DRIVE_FILE_OK) {
     resource_metadata_->set_origin(params->initial_origin);
     RunFeedLoadCallback(params.Pass(), error);
     return;
   }
 
-  scoped_ptr<DocumentFeed>* current_feed = new scoped_ptr<DocumentFeed>;
-  util::PostBlockingPoolSequencedTaskAndReply(
+  scoped_ptr<gdata::DocumentFeed>* current_feed =
+      new scoped_ptr<gdata::DocumentFeed>;
+  gdata::util::PostBlockingPoolSequencedTaskAndReply(
       FROM_HERE,
       blocking_task_runner_,
       base::Bind(&ParseFeedOnBlockingPool,
                  base::Passed(&data),
                  current_feed),
       base::Bind(&GDataWapiFeedLoader::OnParseFeed,
                  weak_ptr_factory_.GetWeakPtr(),
                  base::Passed(&params),
                  start_time,
                  base::Owned(current_feed)));
 }
 
-void GDataWapiFeedLoader::OnParseFeed(scoped_ptr<LoadFeedParams> params,
-                                      base::TimeTicks start_time,
-                                      scoped_ptr<DocumentFeed>* current_feed) {
+void GDataWapiFeedLoader::OnParseFeed(
+    scoped_ptr<LoadFeedParams> params,
+    base::TimeTicks start_time,
+    scoped_ptr<gdata::DocumentFeed>* current_feed) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK(current_feed);
 
   if (!current_feed->get()) {
     RunFeedLoadCallback(params.Pass(), DRIVE_FILE_ERROR_FAILED);
     return;
   }
 
   GURL next_feed_url;
   const bool has_next_feed_url =
@@ skipping 52 matching lines @@
   UMA_HISTOGRAM_TIMES("Drive.EntireFeedLoadTime",
                       base::TimeTicks::Now() - start_time);
 
   // Run the callback so the client can process the retrieved feeds.
   RunFeedLoadCallback(params.Pass(), DRIVE_FILE_OK);
 }
 
 void GDataWapiFeedLoader::OnGetChangelist(
     scoped_ptr<LoadFeedParams> params,
     base::TimeTicks start_time,
-    GDataErrorCode status,
+    gdata::GDataErrorCode status,
     scoped_ptr<base::Value> data) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   if (params->feed_list.empty()) {
     UMA_HISTOGRAM_TIMES("Drive.InitialFeedLoadTime",
                         base::TimeTicks::Now() - start_time);
   }
 
   DriveFileError error = util::GDataToDriveFileError(status);
   if (error == DRIVE_FILE_OK &&
       (!data.get() || data->GetType() != Value::TYPE_DICTIONARY)) {
     error = DRIVE_FILE_ERROR_FAILED;
   }
 
   if (error != DRIVE_FILE_OK) {
     resource_metadata_->set_origin(params->initial_origin);
     RunFeedLoadCallback(params.Pass(), error);
     return;
   }
 
   GURL next_feed_url;
-  scoped_ptr<ChangeList> current_feed(ChangeList::CreateFrom(*data));
+  scoped_ptr<gdata::ChangeList> current_feed(
+      gdata::ChangeList::CreateFrom(*data));
   if (!current_feed.get()) {
     RunFeedLoadCallback(params.Pass(), DRIVE_FILE_ERROR_FAILED);
     return;
   }
   const bool has_next_feed = !current_feed->next_page_token().empty();
 
 #ifndef NDEBUG
   // Save initial root feed for analysis.
   std::string file_name =
       base::StringPrintf("DEBUG_changelist_%" PRId64 ".json",
                          params->start_changestamp);
-  util::PostBlockingPoolSequencedTask(
+  gdata::util::PostBlockingPoolSequencedTask(
       FROM_HERE,
       blocking_task_runner_,
       base::Bind(&SaveFeedOnBlockingPoolForDebugging,
                  cache_->GetCacheDirectoryPath(
                      DriveCache::CACHE_TYPE_META).Append(file_name),
                  base::Passed(&data)));
 #endif
 
   // Add the current feed to the list of collected feeds for this directory.
-  scoped_ptr<DocumentFeed> feed =
-      DocumentFeed::CreateFromChangeList(*current_feed);
+  scoped_ptr<gdata::DocumentFeed> feed =
+      gdata::DocumentFeed::CreateFromChangeList(*current_feed);
   params->feed_list.push_back(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[i]->entries().size();
 
   // Check if we need to collect more data to complete the directory list.
   if (has_next_feed) {
     // Post an UI update event to make the UI smoother.
@@ skipping 182 matching lines @@
   if (UseLevelDB()) {
     resource_metadata_->SaveToDB();
   } else {
     const FilePath path =
         cache_->GetCacheDirectoryPath(DriveCache::CACHE_TYPE_META).Append(
             kFilesystemProtoFile);
     scoped_ptr<std::string> serialized_proto(new std::string());
     resource_metadata_->SerializeToString(serialized_proto.get());
     resource_metadata_->set_last_serialized(base::Time::Now());
     resource_metadata_->set_serialized_size(serialized_proto->size());
-    util::PostBlockingPoolSequencedTask(
+    gdata::util::PostBlockingPoolSequencedTask(
         FROM_HERE,
         blocking_task_runner_,
         base::Bind(&SaveProtoOnBlockingPool, path,
                    base::Passed(serialized_proto.Pass())));
   }
 }
 
 DriveFileError GDataWapiFeedLoader::UpdateFromFeed(
-    const ScopedVector<DocumentFeed>& feed_list,
+    const ScopedVector<gdata::DocumentFeed>& feed_list,
     int64 start_changestamp,
     int64 root_feed_changestamp) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DVLOG(1) << "Updating directory with a feed";
 
   std::set<FilePath> changed_dirs;
 
   GDataWapiFeedProcessor feed_processor(resource_metadata_);
   const DriveFileError 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(GDataWapiFeedLoaderObserver, observers_,
                         OnDirectoryChanged(*dir_iter));
     }
   }
 
   return error;
 }
 
-}  // namespace gdata
+}  // namespace drive