Rename GData* to Drive* in gdata.proto

chrome/browser/chromeos/gdata/gdata_file_system_proxy.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_proxy.h"
 
 #include <string>
 #include <vector>
 
 #include "base/bind.h"
 #include "base/platform_file.h"
 #include "base/string_util.h"
 #include "base/values.h"
-#include "chrome/browser/chromeos/gdata/gdata.pb.h"
+#include "chrome/browser/chromeos/gdata/drive.pb.h"
 #include "chrome/browser/chromeos/gdata/gdata_file_system_interface.h"
 #include "chrome/browser/chromeos/gdata/gdata_files.h"
 #include "chrome/browser/chromeos/gdata/gdata_system_service.h"
 #include "chrome/browser/chromeos/gdata/gdata_util.h"
 #include "content/public/browser/browser_thread.h"
 #include "webkit/blob/shareable_file_reference.h"
 #include "webkit/fileapi/file_system_file_util_proxy.h"
 #include "webkit/fileapi/file_system_types.h"
 #include "webkit/fileapi/file_system_url.h"
 #include "webkit/fileapi/file_system_util.h"
@@ skipping 131 matching lines @@
     base::PlatformFileError truncate_result,
     GDataFileError close_result) {
   // Reports the first error.
   callback.Run(truncate_result == base::PLATFORM_FILE_OK ?
                util::GDataFileErrorToPlatformError(close_result) :
                truncate_result);
 }
 
 }  // namespace
 
-base::FileUtilProxy::Entry GDataEntryProtoToFileUtilProxyEntry(
-    const GDataEntryProto& proto) {
+base::FileUtilProxy::Entry DriveEntryProtoToFileUtilProxyEntry(
+    const DriveEntryProto& proto) {
   base::PlatformFileInfo file_info;
   GDataEntry::ConvertProtoToPlatformFileInfo(proto.file_info(), &file_info);
 
   base::FileUtilProxy::Entry entry;
   entry.name = proto.base_name();
   entry.is_directory = file_info.is_directory;
   entry.size = file_info.size;
   entry.last_modified_time = file_info.last_modified;
   return entry;
 }
@@ skipping 397 matching lines @@
       base::Bind(&GDataFileSystemProxy::OnGetEntryInfoByPath,
                  this,
                  file_path,
                  callback));
 }
 
 void GDataFileSystemProxy::OnGetEntryInfoByPath(
     const FilePath& entry_path,
     const FileSystemOperationInterface::SnapshotFileCallback& callback,
     GDataFileError error,
-    scoped_ptr<GDataEntryProto> entry_proto) {
+    scoped_ptr<DriveEntryProto> entry_proto) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
 
   if (error != GDATA_FILE_OK || !entry_proto.get()) {
     MessageLoopProxy::current()->PostTask(FROM_HERE,
          base::Bind(callback,
                     base::PLATFORM_FILE_ERROR_NOT_FOUND,
                     base::PlatformFileInfo(),
                     FilePath(),
                     scoped_refptr<ShareableFileReference>(NULL)));
     return;
@@ skipping 53 matching lines @@
 void GDataFileSystemProxy::OnStatusCallback(
     const fileapi::FileSystemOperationInterface::StatusCallback& callback,
     GDataFileError error) {
   callback.Run(util::GDataFileErrorToPlatformError(error));
 }
 
 void GDataFileSystemProxy::OnGetMetadata(
     const FilePath& file_path,
     const FileSystemOperationInterface::GetMetadataCallback& callback,
     GDataFileError error,
-    scoped_ptr<GDataEntryProto> entry_proto) {
+    scoped_ptr<DriveEntryProto> entry_proto) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
 
   if (error != GDATA_FILE_OK) {
     callback.Run(util::GDataFileErrorToPlatformError(error),
                  base::PlatformFileInfo(),
                  FilePath());
     return;
   }
   DCHECK(entry_proto.get());
 
   base::PlatformFileInfo file_info;
   GDataEntry::ConvertProtoToPlatformFileInfo(
       entry_proto->file_info(),
       &file_info);
 
   callback.Run(base::PLATFORM_FILE_OK, file_info, file_path);
 }
 
 void GDataFileSystemProxy::OnReadDirectory(
     const FileSystemOperationInterface::ReadDirectoryCallback&
     callback,
     GDataFileError error,
     bool hide_hosted_documents,
-    scoped_ptr<GDataEntryProtoVector> proto_entries) {
+    scoped_ptr<DriveEntryProtoVector> proto_entries) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
 
   if (error != GDATA_FILE_OK) {
     callback.Run(util::GDataFileErrorToPlatformError(error),
                  std::vector<base::FileUtilProxy::Entry>(),
                  false);
     return;
   }
   DCHECK(proto_entries.get());
 
   std::vector<base::FileUtilProxy::Entry> entries;
   // Convert gdata files to something File API stack can understand.
   for (size_t i = 0; i < proto_entries->size(); ++i) {
-    const GDataEntryProto& proto = (*proto_entries)[i];
+    const DriveEntryProto& proto = (*proto_entries)[i];
     if (proto.has_file_specific_info() &&
         proto.file_specific_info().is_hosted_document() &&
         hide_hosted_documents) {
       continue;
     }
-    entries.push_back(GDataEntryProtoToFileUtilProxyEntry(proto));
+    entries.push_back(DriveEntryProtoToFileUtilProxyEntry(proto));
   }
 
   callback.Run(base::PLATFORM_FILE_OK, entries, false);
 }
 
 void GDataFileSystemProxy::OnCreateWritableSnapshotFile(
     const FilePath& virtual_path,
     const fileapi::WritableSnapshotFile& callback,
     GDataFileError result,
     const FilePath& local_path) {
@@ skipping 19 matching lines @@
 void GDataFileSystemProxy::CloseWritableSnapshotFile(
     const FilePath& virtual_path,
     const FilePath& local_path) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
 
   file_system_->CloseFile(virtual_path,
                           base::Bind(&EmitDebugLogForCloseFile, virtual_path));
 }
 
 }  // namespace gdata