Rename GDataErrorCode to DriveErrorCode, GDataFileError to DriveFileError

chrome/browser/chromeos/gdata/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/gdata/gdata_wapi_feed_loader.h"
 
 #include <set>
 
 #include "base/command_line.h"
 #include "base/file_util.h"
@@ skipping 49 matching lines @@
     {-1,  120},  // Any size, dump if older than 120 minutes.
 #endif
 };
 
 // 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;
+    params->load_error = DRIVE_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;
+    params->load_error = DRIVE_FILE_ERROR_NOT_FOUND;
     return;
   }
-  params->load_error = GDATA_FILE_OK;
+  params->load_error = DRIVE_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,
@@ skipping 68 matching lines @@
 }
 
 GetDocumentsParams::~GetDocumentsParams() {
   STLDeleteElements(feed_list.get());
 }
 
 LoadRootFeedParams::LoadRootFeedParams(
     bool should_load_from_server,
     const FileOperationCallback& callback)
     : should_load_from_server(should_load_from_server),
-      load_error(GDATA_FILE_OK),
+      load_error(DRIVE_FILE_OK),
       load_start_time(base::Time::Now()),
       callback(callback) {
 }
 
 LoadRootFeedParams::~LoadRootFeedParams() {
 }
 
 // Defines set of parameters for calling GDataWapiFeedLoader::LoadFromServer().
 // Value of |start_changestamp| determines the type of feed to load - 0 means
 // root feed, every other value would trigger delta feed.
@@ skipping 126 matching lines @@
     GDataErrorCode status,
     scoped_ptr<base::Value> feed_data) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   LoadFeedParams params(initial_origin,
                         base::Bind(&GDataWapiFeedLoader::OnFeedFromServerLoaded,
                                    weak_ptr_factory_.GetWeakPtr()));
   params.start_changestamp = local_changestamp + 1;
   params.load_finished_callback = callback;
 
-  GDataFileError error = util::GDataToGDataFileError(status);
-  if (error != GDATA_FILE_OK) {
+  DriveFileError error = util::GDataToDriveFileError(status);
+  if (error != DRIVE_FILE_OK) {
     // Get changes starting from the next changestamp from what we have locally.
     LoadFromServer(params);
     return;
   }
 
   scoped_ptr<AccountMetadataFeed> account_metadata;
   if (feed_data.get()) {
     account_metadata = AccountMetadataFeed::CreateFrom(*feed_data);
 #ifndef NDEBUG
     // Save account metadata feed for analysis.
@@ skipping 26 matching lines @@
     // If our cache holds the latest state from the server, change the
     // state to FROM_SERVER.
     resource_metadata_->set_origin(
         initial_origin == FROM_CACHE ? FROM_SERVER : initial_origin);
     changes_detected = false;
   }
 
   // No changes detected, tell the client that the loading was successful.
   if (!changes_detected) {
     if (!callback.is_null())
-      callback.Run(GDATA_FILE_OK);
+      callback.Run(DRIVE_FILE_OK);
     return;
   }
 
   // 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);
 }
 
 void GDataWapiFeedLoader::OnGetAboutResource(
     ContentOrigin initial_origin,
     int64 local_changestamp,
     const FileOperationCallback& callback,
     GDataErrorCode status,
     scoped_ptr<base::Value> feed_data) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   LoadFeedParams params(initial_origin,
                         base::Bind(&GDataWapiFeedLoader::OnFeedFromServerLoaded,
                                    weak_ptr_factory_.GetWeakPtr()));
   params.load_finished_callback = callback;
 
-  GDataFileError error = util::GDataToGDataFileError(status);
-  if (error != GDATA_FILE_OK) {
+  DriveFileError error = util::GDataToDriveFileError(status);
+  if (error != DRIVE_FILE_OK) {
     // Get changes starting from the next changestamp from what we have locally.
     LoadFromServer(params);
     return;
   }
 
   scoped_ptr<AboutResource> about_resource;
   if (feed_data.get())
     about_resource = AboutResource::CreateFrom(*feed_data);
 
   if (!about_resource.get()) {
@@ skipping 15 matching lines @@
     // If our cache holds the latest state from the server, change the
     // state to FROM_SERVER.
     resource_metadata_->set_origin(
         initial_origin == FROM_CACHE ? FROM_SERVER : initial_origin);
     changes_detected = false;
   }
 
   // No changes detected, tell the client that the loading was successful.
   if (!changes_detected) {
     if (!callback.is_null())
-      callback.Run(GDATA_FILE_OK);
+      callback.Run(DRIVE_FILE_OK);
     return;
   }
 
   // Load changes from the server.
   params.start_changestamp = local_changestamp > 0 ? local_changestamp + 1 : 0;
   params.root_feed_changestamp = largest_changestamp;
   LoadFromServer(params);
 }
 
 void GDataWapiFeedLoader::OnGetApplicationList(
     GDataErrorCode status,
     scoped_ptr<base::Value> json) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
-  GDataFileError error = util::GDataToGDataFileError(status);
-  if (error != GDATA_FILE_OK)
+  DriveFileError error = util::GDataToDriveFileError(status);
+  if (error != DRIVE_FILE_OK)
     return;
 
   if (json.get()) {
     scoped_ptr<AppList> applist(AppList::CreateFrom(*json));
     if (applist.get()) {
       VLOG(1) << "applist get success";
       webapps_registry_->UpdateFromApplicationList(*applist.get());
     }
   }
 }
@@ skipping 63 matching lines @@
     const std::string& search_query,
     const GURL& next_feed,
     const LoadDocumentFeedCallback& feed_load_callback) {
   LoadFeedParams params(initial_origin, feed_load_callback);
   params.search_query = search_query;
   params.feed_to_load = next_feed;
   LoadFromServer(params);
 }
 
 void GDataWapiFeedLoader::OnFeedFromServerLoaded(GetDocumentsParams* params,
-                                                 GDataFileError error) {
+                                                 DriveFileError error) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
-  if (error != GDATA_FILE_OK) {
+  if (error != DRIVE_FILE_OK) {
     if (!params->callback.is_null())
       params->callback.Run(error);
     return;
   }
 
   error = UpdateFromFeed(*params->feed_list,
                          params->start_changestamp,
                          params->root_feed_changestamp);
 
-  if (error != GDATA_FILE_OK) {
+  if (error != DRIVE_FILE_OK) {
     if (!params->callback.is_null())
       params->callback.Run(error);
 
     return;
   }
 
   // Save file system metadata to disk.
   SaveFileSystem();
 
   // Tell the client that the loading was successful.
   if (!params->callback.is_null()) {
-    params->callback.Run(GDATA_FILE_OK);
+    params->callback.Run(DRIVE_FILE_OK);
   }
 
   FOR_EACH_OBSERVER(Observer, observers_, OnFeedFromServerLoaded());
 }
 
 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));
   DCHECK(!callback.is_null());
 
   if (params->feed_list->empty()) {
     UMA_HISTOGRAM_TIMES("Gdata.InitialFeedLoadTime",
                         base::TimeTicks::Now() - start_time);
   }
 
-  GDataFileError error = util::GDataToGDataFileError(status);
-  if (error == GDATA_FILE_OK &&
+  DriveFileError error = util::GDataToDriveFileError(status);
+  if (error == DRIVE_FILE_OK &&
       (!data.get() || data->GetType() != Value::TYPE_DICTIONARY)) {
-    error = GDATA_FILE_ERROR_FAILED;
+    error = DRIVE_FILE_ERROR_FAILED;
   }
 
-  if (error != GDATA_FILE_OK) {
+  if (error != DRIVE_FILE_OK) {
     resource_metadata_->set_origin(initial_origin);
     callback.Run(params, error);
     return;
   }
 
   GURL next_feed_url;
   scoped_ptr<DocumentFeed> current_feed(DocumentFeed::ExtractAndParse(*data));
   if (!current_feed.get()) {
-    callback.Run(params, GDATA_FILE_ERROR_FAILED);
+    callback.Run(params, DRIVE_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_%" PRId64 ".json",
                          params->start_changestamp);
   util::PostBlockingPoolSequencedTask(
@@ skipping 77 matching lines @@
     GDataErrorCode status,
     scoped_ptr<base::Value> data) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK(!callback.is_null());
 
   if (params->feed_list->empty()) {
     UMA_HISTOGRAM_TIMES("Drive.InitialFeedLoadTime",
                         base::TimeTicks::Now() - start_time);
   }
 
-  GDataFileError error = util::GDataToGDataFileError(status);
-  if (error == GDATA_FILE_OK &&
+  DriveFileError error = util::GDataToDriveFileError(status);
+  if (error == DRIVE_FILE_OK &&
       (!data.get() || data->GetType() != Value::TYPE_DICTIONARY)) {
-    error = GDATA_FILE_ERROR_FAILED;
+    error = DRIVE_FILE_ERROR_FAILED;
   }
 
-  if (error != GDATA_FILE_OK) {
+  if (error != DRIVE_FILE_OK) {
     resource_metadata_->set_origin(initial_origin);
     callback.Run(params, error);
     return;
   }
 
   GURL next_feed_url;
   scoped_ptr<ChangeList> current_feed(ChangeList::CreateFrom(*data));
   if (!current_feed.get()) {
-    callback.Run(params, GDATA_FILE_ERROR_FAILED);
+    callback.Run(params, 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(
@@ skipping 135 matching lines @@
 
 void GDataWapiFeedLoader::OnProtoLoaded(LoadRootFeedParams* params) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   // If we have already received updates from the server, bail out.
   if (resource_metadata_->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) {
+  if (params->load_error == DRIVE_FILE_OK) {
     DVLOG(1) << "ParseFromString";
     if (resource_metadata_->ParseFromString(params->proto)) {
       resource_metadata_->set_last_serialized(params->last_modified);
       resource_metadata_->set_serialized_size(params->proto.size());
     } else {
-      params->load_error = GDATA_FILE_ERROR_FAILED;
+      params->load_error = DRIVE_FILE_ERROR_FAILED;
       LOG(WARNING) << "Parse of cached proto file failed";
     }
   }
 
   ContinueWithInitializedDirectoryService(params, params->load_error);
 }
 
 void GDataWapiFeedLoader::ContinueWithInitializedDirectoryService(
     LoadRootFeedParams* params,
-    GDataFileError error) {
+    DriveFileError 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";
 
   // TODO(satorux): Simplify the callback handling. crbug.com/142799
   FileOperationCallback callback = params->callback;
   // If we got feed content from cache, tell the client that the loading was
   // successful.
-  if (error == GDATA_FILE_OK && !callback.is_null()) {
-    callback.Run(GDATA_FILE_OK);
+  if (error == DRIVE_FILE_OK && !callback.is_null()) {
+    callback.Run(DRIVE_FILE_OK);
     // Reset the callback so we don't run the same callback once
     // ReloadFeedFromServerIfNeeded() is complete.
     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
@@ skipping 35 matching lines @@
     resource_metadata_->set_last_serialized(base::Time::Now());
     resource_metadata_->set_serialized_size(serialized_proto->size());
     util::PostBlockingPoolSequencedTask(
         FROM_HERE,
         blocking_task_runner_,
         base::Bind(&SaveProtoOnBlockingPool, path,
                    base::Passed(serialized_proto.Pass())));
   }
 }
 
-GDataFileError GDataWapiFeedLoader::UpdateFromFeed(
+DriveFileError GDataWapiFeedLoader::UpdateFromFeed(
     const std::vector<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 GDataFileError error = feed_processor.ApplyFeeds(
+  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(Observer, observers_,
                         OnDirectoryChanged(*dir_iter));
     }
   }
 
   return error;
 }
 
 }  // namespace gdata