Rename GData* to Drive* in gdata.proto

chrome/browser/chromeos/gdata/gdata_directory_service.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_directory_service.h"
 
 #include <leveldb/db.h>
 #include <utility>
 
 #include "base/message_loop_proxy.h"
 #include "base/string_number_conversions.h"
 #include "base/sequenced_task_runner.h"
 #include "base/tracked_objects.h"
-#include "chrome/browser/chromeos/gdata/gdata.pb.h"
+#include "chrome/browser/chromeos/gdata/drive.pb.h"
 #include "chrome/browser/chromeos/gdata/gdata_files.h"
 #include "chrome/browser/chromeos/gdata/gdata_util.h"
 #include "chrome/browser/chromeos/gdata/gdata_wapi_parser.h"
 #include "content/public/browser/browser_thread.h"
 
 using content::BrowserThread;
 
 namespace gdata {
 namespace {
 
@@ skipping 303 matching lines @@
   GDataEntry* entry = GetEntryByResourceId(resource_id);
   callback.Run(entry);
 }
 
 void GDataDirectoryService::GetEntryInfoByResourceId(
       const std::string& resource_id,
       const GetEntryInfoWithFilePathCallback& callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK(!callback.is_null());
 
-  scoped_ptr<GDataEntryProto> entry_proto;
+  scoped_ptr<DriveEntryProto> entry_proto;
   GDataFileError error = GDATA_FILE_ERROR_FAILED;
   FilePath drive_file_path;
 
   GDataEntry* entry = GetEntryByResourceId(resource_id);
   if (entry) {
-    entry_proto.reset(new GDataEntryProto);
+    entry_proto.reset(new DriveEntryProto);
     entry->ToProtoFull(entry_proto.get());
     error = GDATA_FILE_OK;
     drive_file_path = entry->GetFilePath();
   } else {
     error = GDATA_FILE_ERROR_NOT_FOUND;
   }
 
   base::MessageLoopProxy::current()->PostTask(
       FROM_HERE,
       base::Bind(callback,
                  error,
                  drive_file_path,
                  base::Passed(&entry_proto)));
 }
 
 void GDataDirectoryService::GetEntryInfoByPath(
     const FilePath& path,
     const GetEntryInfoCallback& callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK(!callback.is_null());
 
-  scoped_ptr<GDataEntryProto> entry_proto;
+  scoped_ptr<DriveEntryProto> entry_proto;
   GDataFileError error = GDATA_FILE_ERROR_FAILED;
 
   GDataEntry* entry = FindEntryByPathSync(path);
   if (entry) {
-    entry_proto.reset(new GDataEntryProto);
+    entry_proto.reset(new DriveEntryProto);
     entry->ToProtoFull(entry_proto.get());
     error = GDATA_FILE_OK;
   } else {
     error = GDATA_FILE_ERROR_NOT_FOUND;
   }
 
   base::MessageLoopProxy::current()->PostTask(
       FROM_HERE,
       base::Bind(callback, error, base::Passed(&entry_proto)));
 }
 
 void GDataDirectoryService::ReadDirectoryByPath(
     const FilePath& path,
     const ReadDirectoryCallback& callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK(!callback.is_null());
 
-  scoped_ptr<GDataEntryProtoVector> entries;
+  scoped_ptr<DriveEntryProtoVector> entries;
   GDataFileError error = GDATA_FILE_ERROR_FAILED;
 
   GDataEntry* entry = FindEntryByPathSync(path);
   if (entry && entry->AsGDataDirectory()) {
     entries = entry->AsGDataDirectory()->ToProtoVector();
     error = GDATA_FILE_OK;
   } else if (entry && !entry->AsGDataDirectory()) {
     error = GDATA_FILE_ERROR_NOT_A_DIRECTORY;
   } else {
     error = GDATA_FILE_ERROR_NOT_FOUND;
@@ skipping 224 matching lines @@
 
   if (!blocking_task_runner_ || !directory_service_db_.get()) {
     NOTREACHED();
     return;
   }
 
   size_t serialized_size = 0;
   SerializedMap serialized_resources;
   for (ResourceMap::const_iterator iter = resource_map_.begin();
       iter != resource_map_.end(); ++iter) {
-    GDataEntryProto proto;
+    DriveEntryProto proto;
     iter->second->ToProtoFull(&proto);
     std::string serialized_string;
     const bool ok = proto.SerializeToString(&serialized_string);
     DCHECK(ok);
     if (ok) {
       serialized_resources.insert(
           std::make_pair(std::string(kDBKeyResourceIdPrefix) + iter->first,
                          serialized_string));
       serialized_size += serialized_string.size();
     }
   }
 
   serialized_resources.insert(std::make_pair(kDBKeyVersion,
       base::IntToString(kProtoVersion)));
   serialized_resources.insert(std::make_pair(kDBKeyLargestChangestamp,
       base::IntToString(largest_changestamp_)));
   set_last_serialized(base::Time::Now());
   set_serialized_size(serialized_size);
 
   blocking_task_runner_->PostTask(
       FROM_HERE,
       base::Bind(&ResourceMetadataDB::Save,
                  base::Unretained(directory_service_db_.get()),
                  serialized_resources));
 }
 
 void GDataDirectoryService::SerializeToString(
     std::string* serialized_proto) const {
-  GDataRootDirectoryProto proto;
+  DriveRootDirectoryProto proto;
   root_->ToProto(proto.mutable_gdata_directory());
   proto.set_largest_changestamp(largest_changestamp_);
   proto.set_version(kProtoVersion);
 
   const bool ok = proto.SerializeToString(serialized_proto);
   DCHECK(ok);
 }
 
 bool GDataDirectoryService::ParseFromString(
     const std::string& serialized_proto) {
-  GDataRootDirectoryProto proto;
+  DriveRootDirectoryProto proto;
   if (!proto.ParseFromString(serialized_proto))
     return false;
 
   if (proto.version() != kProtoVersion) {
     LOG(ERROR) << "Incompatible proto detected (incompatible version): "
                << proto.version();
     return false;
   }
 
   root_->FromProto(proto.gdata_directory());
 
   origin_ = FROM_CACHE;
   largest_changestamp_ = proto.largest_changestamp();
 
   return true;
 }
 
 scoped_ptr<GDataEntry> GDataDirectoryService::FromProtoString(
     const std::string& serialized_proto) {
-  GDataEntryProto entry_proto;
+  DriveEntryProto entry_proto;
   if (!entry_proto.ParseFromString(serialized_proto))
     return scoped_ptr<GDataEntry>();
 
   scoped_ptr<GDataEntry> entry;
   if (entry_proto.file_info().is_directory()) {
     entry.reset(CreateGDataDirectory());
     // Call GDataEntry::FromProto instead of GDataDirectory::FromProto because
     // the proto does not include children.
     entry->FromProto(entry_proto);
   } else {
     scoped_ptr<GDataFile> file(CreateGDataFile());
     // Call GDataFile::FromProto.
     file->FromProto(entry_proto);
     entry.reset(file.release());
   }
   return entry.Pass();
 }
 
 void GDataDirectoryService::GetEntryInfoPairByPathsAfterGetFirst(
     const FilePath& first_path,
     const FilePath& second_path,
     const GetEntryInfoPairCallback& callback,
     GDataFileError error,
-    scoped_ptr<GDataEntryProto> entry_proto) {
+    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) {
     callback.Run(result.Pass());
     return;
   }
 
   // Get the second entry.
   GetEntryInfoByPath(
       second_path,
       base::Bind(&GDataDirectoryService::GetEntryInfoPairByPathsAfterGetSecond,
                  weak_ptr_factory_.GetWeakPtr(),
                  second_path,
                  callback,
                  base::Passed(&result)));
 }
 
 void GDataDirectoryService::GetEntryInfoPairByPathsAfterGetSecond(
     const FilePath& second_path,
     const GetEntryInfoPairCallback& callback,
     scoped_ptr<EntryInfoPairResult> result,
     GDataFileError error,
-    scoped_ptr<GDataEntryProto> entry_proto) {
+    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