Rename GData* to Drive* in gdata.proto

chrome/browser/chromeos/gdata/gdata_files.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_files.h"
 
 #include "base/platform_file.h"
 #include "base/string_util.h"
 #include "base/stringprintf.h"
 #include "base/utf_string_conversions.h"
-#include "chrome/browser/chromeos/gdata/gdata.pb.h"
+#include "chrome/browser/chromeos/gdata/drive.pb.h"
 #include "chrome/browser/chromeos/gdata/gdata_directory_service.h"
 #include "chrome/browser/chromeos/gdata/gdata_wapi_parser.h"
 #include "net/base/escape.h"
 
 namespace gdata {
 namespace {
 
 const char kSlash[] = "/";
 const char kEscapedSlash[] = "\xE2\x88\x95";
 
@@ skipping 350 matching lines @@
     const base::PlatformFileInfo& file_info,
     PlatformFileInfoProto* proto) {
   proto->set_size(file_info.size);
   proto->set_is_directory(file_info.is_directory);
   proto->set_is_symbolic_link(file_info.is_symbolic_link);
   proto->set_last_modified(file_info.last_modified.ToInternalValue());
   proto->set_last_accessed(file_info.last_accessed.ToInternalValue());
   proto->set_creation_time(file_info.creation_time.ToInternalValue());
 }
 
-void GDataEntry::FromProto(const GDataEntryProto& proto) {
+void GDataEntry::FromProto(const DriveEntryProto& proto) {
   ConvertProtoToPlatformFileInfo(proto.file_info(), &file_info_);
 
   // Don't copy from proto.base_name() as base_name_ is computed in
   // SetBaseNameFromTitle().
   title_ = proto.title();
   resource_id_ = proto.resource_id();
   parent_resource_id_ = proto.parent_resource_id();
   edit_url_ = GURL(proto.edit_url());
   content_url_ = GURL(proto.content_url());
   upload_url_ = GURL(proto.upload_url());
   SetBaseNameFromTitle();
 }
 
-void GDataEntry::ToProto(GDataEntryProto* proto) const {
+void GDataEntry::ToProto(DriveEntryProto* proto) const {
   ConvertPlatformFileInfoToProto(file_info_, proto->mutable_file_info());
 
   // The base_name field is used in GetFileInfoByPathAsync(). As shown in
   // FromProto(), the value is discarded when deserializing from proto.
   proto->set_base_name(base_name_);
   proto->set_title(title_);
   proto->set_resource_id(resource_id_);
   proto->set_parent_resource_id(parent_resource_id_);
   proto->set_edit_url(edit_url_.spec());
   proto->set_content_url(content_url_.spec());
   proto->set_upload_url(upload_url_.spec());
 }
 
-void GDataEntry::ToProtoFull(GDataEntryProto* proto) const {
+void GDataEntry::ToProtoFull(DriveEntryProto* proto) const {
   if (AsGDataFileConst()) {
     AsGDataFileConst()->ToProto(proto);
   } else if (AsGDataDirectoryConst()) {
     // Unlike files, directories don't have directory specific info, so just
     // calling GDataEntry::ToProto().
     ToProto(proto);
   } else {
     NOTREACHED();
   }
 }
 
-void GDataFile::FromProto(const GDataEntryProto& proto) {
+void GDataFile::FromProto(const DriveEntryProto& proto) {
   DCHECK(!proto.file_info().is_directory());
 
   GDataEntry::FromProto(proto);
 
   thumbnail_url_ = GURL(proto.file_specific_info().thumbnail_url());
   alternate_url_ = GURL(proto.file_specific_info().alternate_url());
   content_mime_type_ = proto.file_specific_info().content_mime_type();
   file_md5_ = proto.file_specific_info().file_md5();
   document_extension_ = proto.file_specific_info().document_extension();
   is_hosted_document_ = proto.file_specific_info().is_hosted_document();
 }
 
-void GDataFile::ToProto(GDataEntryProto* proto) const {
+void GDataFile::ToProto(DriveEntryProto* proto) const {
   GDataEntry::ToProto(proto);
   DCHECK(!proto->file_info().is_directory());
-  GDataFileSpecificInfo* file_specific_info =
+  DriveFileSpecificInfo* file_specific_info =
       proto->mutable_file_specific_info();
   file_specific_info->set_thumbnail_url(thumbnail_url_.spec());
   file_specific_info->set_alternate_url(alternate_url_.spec());
   file_specific_info->set_content_mime_type(content_mime_type_);
   file_specific_info->set_file_md5(file_md5_);
   file_specific_info->set_document_extension(document_extension_);
   file_specific_info->set_is_hosted_document(is_hosted_document_);
 }
 
-void GDataDirectory::FromProto(const GDataDirectoryProto& proto) {
+void GDataDirectory::FromProto(const DriveDirectoryProto& proto) {
   DCHECK(proto.gdata_entry().file_info().is_directory());
   DCHECK(!proto.gdata_entry().has_file_specific_info());
 
   for (int i = 0; i < proto.child_files_size(); ++i) {
     scoped_ptr<GDataFile> file(directory_service_->CreateGDataFile());
     file->FromProto(proto.child_files(i));
     AddEntry(file.release());
   }
   for (int i = 0; i < proto.child_directories_size(); ++i) {
     scoped_ptr<GDataDirectory> dir(directory_service_->CreateGDataDirectory());
     dir->FromProto(proto.child_directories(i));
     AddEntry(dir.release());
   }
 
   // The states of the directory should be updated after children are
   // handled successfully, so that incomplete states are not left.
   GDataEntry::FromProto(proto.gdata_entry());
 }
 
-void GDataDirectory::ToProto(GDataDirectoryProto* proto) const {
+void GDataDirectory::ToProto(DriveDirectoryProto* proto) const {
   GDataEntry::ToProto(proto->mutable_gdata_entry());
   DCHECK(proto->gdata_entry().file_info().is_directory());
 
   for (GDataChildMap::const_iterator iter = child_files_.begin();
        iter != child_files_.end(); ++iter) {
     GDataFile* file = directory_service_->GetEntryByResourceId(
         iter->second)->AsGDataFile();
     DCHECK(file);
     file->ToProto(proto->add_child_files());
   }
   for (GDataChildMap::const_iterator iter = child_directories_.begin();
        iter != child_directories_.end(); ++iter) {
     GDataDirectory* dir = directory_service_->GetEntryByResourceId(
         iter->second)->AsGDataDirectory();
     DCHECK(dir);
     dir->ToProto(proto->add_child_directories());
   }
 }
 
-scoped_ptr<GDataEntryProtoVector> GDataDirectory::ToProtoVector() const {
-  scoped_ptr<GDataEntryProtoVector> entries(new GDataEntryProtoVector);
+scoped_ptr<DriveEntryProtoVector> GDataDirectory::ToProtoVector() const {
+  scoped_ptr<DriveEntryProtoVector> entries(new DriveEntryProtoVector);
   // Use ToProtoFull, as we don't want to include children in |proto|.
   for (GDataChildMap::const_iterator iter = child_files_.begin();
        iter != child_files_.end(); ++iter) {
-    GDataEntryProto proto;
+    DriveEntryProto proto;
     directory_service_->GetEntryByResourceId(iter->second)->ToProtoFull(&proto);
     entries->push_back(proto);
   }
   for (GDataChildMap::const_iterator iter = child_directories_.begin();
        iter != child_directories_.end(); ++iter) {
-    GDataEntryProto proto;
+    DriveEntryProto proto;
     directory_service_->GetEntryByResourceId(iter->second)->ToProtoFull(&proto);
     entries->push_back(proto);
   }
 
   return entries.Pass();
 }
 
 void GDataEntry::SerializeToString(std::string* serialized_proto) const {
   const GDataFile* file = AsGDataFileConst();
   const GDataDirectory* dir = AsGDataDirectoryConst();
 
   if (file) {
-    GDataEntryProto entry_proto;
+    DriveEntryProto entry_proto;
     file->ToProto(&entry_proto);
     const bool ok = entry_proto.SerializeToString(serialized_proto);
     DCHECK(ok);
   } else if (dir) {
-    GDataDirectoryProto dir_proto;
+    DriveDirectoryProto dir_proto;
     dir->ToProto(&dir_proto);
     const bool ok = dir_proto.SerializeToString(serialized_proto);
     DCHECK(ok);
   }
 }
 
 }  // namespace gdata