Rename GDataErrorCode to DriveErrorCode, GDataFileError to DriveFileError

chrome/browser/chromeos/gdata/drive_resource_metadata.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/drive_resource_metadata.h"
 
 #include <leveldb/db.h>
 #include <utility>
 
 #include "base/message_loop_proxy.h"
@@ skipping 12 matching lines @@
 namespace {
 
 // m: prefix for filesystem metadata db keys, version and largest_changestamp.
 // r: prefix for resource id db keys.
 const char kDBKeyLargestChangestamp[] = "m:largest_changestamp";
 const char kDBKeyVersion[] = "m:version";
 const char kDBKeyResourceIdPrefix[] = "r:";
 
 }  // namespace
 
-EntryInfoResult::EntryInfoResult() : error(GDATA_FILE_ERROR_FAILED) {
+EntryInfoResult::EntryInfoResult() : error(DRIVE_FILE_ERROR_FAILED) {
 }
 
 EntryInfoResult::~EntryInfoResult() {
 }
 
 EntryInfoPairResult::EntryInfoPairResult() {
 }
 
 EntryInfoPairResult::~EntryInfoPairResult() {
 }
@@ skipping 179 matching lines @@
     DriveDirectory* directory,
     DriveEntry* new_entry,
     const FileMoveCallback& callback) {
   DCHECK(directory);
   DCHECK(new_entry);
   DCHECK(!callback.is_null());
 
   directory->AddEntry(new_entry);
   DVLOG(1) << "AddEntryToDirectory " << new_entry->GetFilePath().value();
   base::MessageLoopProxy::current()->PostTask(FROM_HERE,
-      base::Bind(callback, GDATA_FILE_OK, new_entry->GetFilePath()));
+      base::Bind(callback, DRIVE_FILE_OK, new_entry->GetFilePath()));
 }
 
 void DriveResourceMetadata::MoveEntryToDirectory(
     const FilePath& directory_path,
     DriveEntry* entry,
     const FileMoveCallback& callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK(entry);
   DCHECK(!callback.is_null());
 
   if (entry->parent())
     entry->parent()->RemoveChild(entry);
 
   DriveEntry* destination = FindEntryByPathSync(directory_path);
   FilePath moved_file_path;
-  GDataFileError error = GDATA_FILE_ERROR_FAILED;
+  DriveFileError error = DRIVE_FILE_ERROR_FAILED;
   if (!destination) {
-    error = GDATA_FILE_ERROR_NOT_FOUND;
+    error = DRIVE_FILE_ERROR_NOT_FOUND;
   } else if (!destination->AsDriveDirectory()) {
-    error = GDATA_FILE_ERROR_NOT_A_DIRECTORY;
+    error = DRIVE_FILE_ERROR_NOT_A_DIRECTORY;
   } else {
     destination->AsDriveDirectory()->AddEntry(entry);
     moved_file_path = entry->GetFilePath();
-    error = GDATA_FILE_OK;
+    error = DRIVE_FILE_OK;
   }
   DVLOG(1) << "MoveEntryToDirectory " << moved_file_path.value();
   base::MessageLoopProxy::current()->PostTask(
       FROM_HERE, base::Bind(callback, error, moved_file_path));
 }
 
 void DriveResourceMetadata::RemoveEntryFromParent(
     DriveEntry* entry,
     const FileMoveCallback& callback) {
   DriveDirectory* parent = entry->parent();
   DCHECK(parent);
   DCHECK(!callback.is_null());
   DVLOG(1) << "RemoveEntryFromParent " << entry->GetFilePath().value();
 
   parent->RemoveEntry(entry);
   base::MessageLoopProxy::current()->PostTask(FROM_HERE,
-      base::Bind(callback, GDATA_FILE_OK, parent->GetFilePath()));
+      base::Bind(callback, DRIVE_FILE_OK, parent->GetFilePath()));
 }
 
 void DriveResourceMetadata::AddEntryToResourceMap(DriveEntry* entry) {
   DVLOG(1) << "AddEntryToResourceMap " << entry->resource_id();
   DCHECK(!entry->resource_id().empty());
   std::pair<ResourceMap::iterator, bool> ret =
       resource_map_.insert(std::make_pair(entry->resource_id(), entry));
   DCHECK(ret.second);  // resource_id did not previously exist in the map.
 }
 
@@ skipping 44 matching lines @@
   callback.Run(entry);
 }
 
 void DriveResourceMetadata::GetEntryInfoByResourceId(
       const std::string& resource_id,
       const GetEntryInfoWithFilePathCallback& callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK(!callback.is_null());
 
   scoped_ptr<DriveEntryProto> entry_proto;
-  GDataFileError error = GDATA_FILE_ERROR_FAILED;
+  DriveFileError error = DRIVE_FILE_ERROR_FAILED;
   FilePath drive_file_path;
 
   DriveEntry* entry = GetEntryByResourceId(resource_id);
   if (entry) {
     entry_proto.reset(new DriveEntryProto);
     entry->ToProtoFull(entry_proto.get());
-    error = GDATA_FILE_OK;
+    error = DRIVE_FILE_OK;
     drive_file_path = entry->GetFilePath();
   } else {
-    error = GDATA_FILE_ERROR_NOT_FOUND;
+    error = DRIVE_FILE_ERROR_NOT_FOUND;
   }
 
   base::MessageLoopProxy::current()->PostTask(
       FROM_HERE,
       base::Bind(callback,
                  error,
                  drive_file_path,
                  base::Passed(&entry_proto)));
 }
 
 void DriveResourceMetadata::GetEntryInfoByPath(
     const FilePath& path,
     const GetEntryInfoCallback& callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK(!callback.is_null());
 
   scoped_ptr<DriveEntryProto> entry_proto;
-  GDataFileError error = GDATA_FILE_ERROR_FAILED;
+  DriveFileError error = DRIVE_FILE_ERROR_FAILED;
 
   DriveEntry* entry = FindEntryByPathSync(path);
   if (entry) {
     entry_proto.reset(new DriveEntryProto);
     entry->ToProtoFull(entry_proto.get());
-    error = GDATA_FILE_OK;
+    error = DRIVE_FILE_OK;
   } else {
-    error = GDATA_FILE_ERROR_NOT_FOUND;
+    error = DRIVE_FILE_ERROR_NOT_FOUND;
   }
 
   base::MessageLoopProxy::current()->PostTask(
       FROM_HERE,
       base::Bind(callback, error, base::Passed(&entry_proto)));
 }
 
 void DriveResourceMetadata::ReadDirectoryByPath(
     const FilePath& path,
     const ReadDirectoryCallback& callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK(!callback.is_null());
 
   scoped_ptr<DriveEntryProtoVector> entries;
-  GDataFileError error = GDATA_FILE_ERROR_FAILED;
+  DriveFileError error = DRIVE_FILE_ERROR_FAILED;
 
   DriveEntry* entry = FindEntryByPathSync(path);
   if (entry && entry->AsDriveDirectory()) {
     entries = entry->AsDriveDirectory()->ToProtoVector();
-    error = GDATA_FILE_OK;
+    error = DRIVE_FILE_OK;
   } else if (entry && !entry->AsDriveDirectory()) {
-    error = GDATA_FILE_ERROR_NOT_A_DIRECTORY;
+    error = DRIVE_FILE_ERROR_NOT_A_DIRECTORY;
   } else {
-    error = GDATA_FILE_ERROR_NOT_FOUND;
+    error = DRIVE_FILE_ERROR_NOT_FOUND;
   }
 
   base::MessageLoopProxy::current()->PostTask(
       FROM_HERE,
       base::Bind(callback, error, base::Passed(&entries)));
 }
 
 void DriveResourceMetadata::GetEntryInfoPairByPaths(
     const FilePath& first_path,
     const FilePath& second_path,
@@ skipping 49 matching lines @@
 }
 
 // static
 void DriveResourceMetadata::RefreshDirectoryInternal(
     const ResourceMap& file_map,
     const FileMoveCallback& callback,
     DriveEntry* directory_entry) {
   DCHECK(!callback.is_null());
 
   if (!directory_entry) {
-    callback.Run(GDATA_FILE_ERROR_NOT_FOUND, FilePath());
+    callback.Run(DRIVE_FILE_ERROR_NOT_FOUND, FilePath());
     return;
   }
 
   DriveDirectory* directory = directory_entry->AsDriveDirectory();
   if (!directory) {
-    callback.Run(GDATA_FILE_ERROR_NOT_A_DIRECTORY, FilePath());
+    callback.Run(DRIVE_FILE_ERROR_NOT_A_DIRECTORY, FilePath());
     return;
   }
 
   DVLOG(1) << "RefreshDirectoryInternal";
   directory->RemoveChildFiles();
   // Add files from file_map.
   for (ResourceMap::const_iterator it = file_map.begin();
        it != file_map.end(); ++it) {
     scoped_ptr<DriveEntry> entry(it->second);
     // Skip if it's not a file (i.e. directory).
     if (!entry->AsDriveFile())
       continue;
     directory->AddEntry(entry.release());
   }
 
-  callback.Run(GDATA_FILE_OK, directory->GetFilePath());
+  callback.Run(DRIVE_FILE_OK, directory->GetFilePath());
 }
 
 void DriveResourceMetadata::InitFromDB(
     const FilePath& db_path,
     base::SequencedTaskRunner* blocking_task_runner,
     const FileOperationCallback& callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK(!db_path.empty());
   DCHECK(blocking_task_runner);
 
   if (resource_metadata_db_.get()) {
     if (!callback.is_null())
-      callback.Run(GDATA_FILE_ERROR_FAILED);
+      callback.Run(DRIVE_FILE_ERROR_FAILED);
     return;
   }
 
   blocking_task_runner_ = blocking_task_runner;
 
   DVLOG(1) << "InitFromDB " << db_path.value();
 
   CreateDBParams* create_params =
       new CreateDBParams(db_path, blocking_task_runner);
   blocking_task_runner_->PostTaskAndReply(
@@ skipping 11 matching lines @@
     const FileOperationCallback& callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK(create_params);
   DCHECK(!resource_metadata_db_.get());
 
   SerializedMap* serialized_resources = &create_params->serialized_resources;
   resource_metadata_db_ = create_params->db.Pass();
   if (serialized_resources->empty()) {
     origin_ = INITIALIZING;
     if (!callback.is_null())
-      callback.Run(GDATA_FILE_ERROR_NOT_FOUND);
+      callback.Run(DRIVE_FILE_ERROR_NOT_FOUND);
     return;
   }
 
   ClearRoot();
 
   // Version check.
   int32 version = 0;
   SerializedMap::iterator iter = serialized_resources->find(kDBKeyVersion);
   if (iter == serialized_resources->end() ||
       !base::StringToInt(iter->second, &version) ||
       version != kProtoVersion) {
     if (!callback.is_null())
-      callback.Run(GDATA_FILE_ERROR_FAILED);
+      callback.Run(DRIVE_FILE_ERROR_FAILED);
     return;
   }
   serialized_resources->erase(iter);
 
   // Get the largest changestamp.
   iter = serialized_resources->find(kDBKeyLargestChangestamp);
   if (iter == serialized_resources->end() ||
       !base::StringToInt64(iter->second, &largest_changestamp_)) {
     NOTREACHED() << "Could not find/parse largest_changestamp";
     if (!callback.is_null())
-      callback.Run(GDATA_FILE_ERROR_FAILED);
+      callback.Run(DRIVE_FILE_ERROR_FAILED);
     return;
   } else {
     DVLOG(1) << "InitResourceMap largest_changestamp_" << largest_changestamp_;
     serialized_resources->erase(iter);
   }
 
   ResourceMap resource_map;
   for (SerializedMap::const_iterator iter = serialized_resources->begin();
       iter != serialized_resources->end(); ++iter) {
     if (iter->first.find(kDBKeyResourceIdPrefix) != 0) {
@@ skipping 38 matching lines @@
     }
   }
 
   DCHECK(root_.get());
   DCHECK_EQ(resource_map.size(), resource_map_.size());
   DCHECK_EQ(resource_map.size(), serialized_resources->size());
 
   origin_ = FROM_CACHE;
 
   if (!callback.is_null())
-    callback.Run(GDATA_FILE_OK);
+    callback.Run(DRIVE_FILE_OK);
 }
 
 void DriveResourceMetadata::SaveToDB() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   if (!blocking_task_runner_ || !resource_metadata_db_.get()) {
     NOTREACHED();
     return;
   }
 
@@ skipping 77 matching lines @@
     file->FromProto(entry_proto);
     entry.reset(file.release());
   }
   return entry.Pass();
 }
 
 void DriveResourceMetadata::GetEntryInfoPairByPathsAfterGetFirst(
     const FilePath& first_path,
     const FilePath& second_path,
     const GetEntryInfoPairCallback& callback,
-    GDataFileError error,
+    DriveFileError error,
     scoped_ptr<DriveEntryProto> entry_proto) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK(!callback.is_null());
 
   scoped_ptr<EntryInfoPairResult> result(new EntryInfoPairResult);
   result->first.path = first_path;
   result->first.error = error;
   result->first.proto = entry_proto.Pass();
 
   // If the first one is not found, don't continue.
-  if (error != GDATA_FILE_OK) {
+  if (error != DRIVE_FILE_OK) {
     callback.Run(result.Pass());
     return;
   }
 
   // Get the second entry.
   GetEntryInfoByPath(
       second_path,
       base::Bind(&DriveResourceMetadata::GetEntryInfoPairByPathsAfterGetSecond,
                  weak_ptr_factory_.GetWeakPtr(),
                  second_path,
                  callback,
                  base::Passed(&result)));
 }
 
 void DriveResourceMetadata::GetEntryInfoPairByPathsAfterGetSecond(
     const FilePath& second_path,
     const GetEntryInfoPairCallback& callback,
     scoped_ptr<EntryInfoPairResult> result,
-    GDataFileError error,
+    DriveFileError error,
     scoped_ptr<DriveEntryProto> entry_proto) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK(!callback.is_null());
   DCHECK(result.get());
 
   result->second.path = second_path;
   result->second.error = error;
   result->second.proto = entry_proto.Pass();
 
   callback.Run(result.Pass());
 }
 
 }  // namespace gdata