Rename GData* to Drive* in gdata.proto

chrome/browser/chromeos/gdata/gdata_directory_service.h

 // 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.
 
 #ifndef CHROME_BROWSER_CHROMEOS_GDATA_GDATA_DIRECTORY_SERVICE_H_
 #define CHROME_BROWSER_CHROMEOS_GDATA_GDATA_DIRECTORY_SERVICE_H_
 
 #include <map>
 #include <string>
 #include <vector>
 
 #include "base/callback.h"
 #include "base/file_path.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/memory/weak_ptr.h"
 #include "base/time.h"
 #include "chrome/browser/chromeos/gdata/gdata_errorcode.h"
 
 namespace base {
 class SequencedTaskRunner;
 }
 
 namespace gdata {
 
 struct CreateDBParams;
 class DocumentEntry;
+class DriveEntryProto;
+class GDataDirectory;
 class GDataEntry;
-class GDataEntryProto;
 class GDataFile;
-class GDataDirectory;
 class ResourceMetadataDB;
 
-typedef std::vector<GDataEntryProto> GDataEntryProtoVector;
+typedef std::vector<DriveEntryProto> DriveEntryProtoVector;
 
 // File type on the gdata file system can be either a regular file or
 // a hosted document.
 enum GDataFileType {
   REGULAR_FILE,
   HOSTED_DOCUMENT,
 };
 
 // The root directory content origin.
 enum ContentOrigin {
@@ skipping 11 matching lines @@
 // The root directory name used for the Google Drive file system tree. The
 // name is used in URLs for the file manager, hence user-visible.
 const FilePath::CharType kGDataRootDirectory[] = FILE_PATH_LITERAL("drive");
 
 // The resource ID for the root directory is defined in the spec:
 // https://developers.google.com/google-apps/documents-list/
 const char kGDataRootDirectoryResourceId[] = "folder:root";
 
 // This should be incremented when incompatibility change is made in
 // gdata.proto.
 const int32 kProtoVersion = 2;

[achuithb, 2012/08/21 09:23:45]

I think you also need to bump this number to 3.

[kochi, 2012/08/21 09:37:34]

I don't think so.
The name of the proto is changed, but the cardinals of the
proto members are unchanged, thus the saved protos can
be read as is by the renamed new protos.

 
 // Callback type used to get result of file search.
 // If |error| is not PLATFORM_FILE_OK, |entry| is set to NULL.
 typedef base::Callback<void(GDataFileError error, GDataEntry* entry)>
     FindEntryCallback;
 
 // Used for file operations like removing files.
 typedef base::Callback<void(GDataFileError error)>
     FileOperationCallback;
 
 // Callback similar to FileOperationCallback but with a given |file_path|.
 // Used for operations that change a file path like moving files.
 typedef base::Callback<void(GDataFileError error,
                             const FilePath& file_path)>
     FileMoveCallback;
 
 // Used to get entry info from the file system.
 // If |error| is not GDATA_FILE_OK, |entry_info| is set to NULL.
 typedef base::Callback<void(GDataFileError error,
-                            scoped_ptr<GDataEntryProto> entry_proto)>
+                            scoped_ptr<DriveEntryProto> entry_proto)>
     GetEntryInfoCallback;
 
 typedef base::Callback<void(GDataFileError error,
-                            scoped_ptr<GDataEntryProtoVector> entries)>
+                            scoped_ptr<DriveEntryProtoVector> entries)>
     ReadDirectoryCallback;
 
 // Used to get entry info from the file system, with the Drive file path.
 // If |error| is not GDATA_FILE_OK, |entry_proto| is set to NULL.
 //
-// |drive_file_path| parameter is provided as GDataEntryProto does not contain
+// |drive_file_path| parameter is provided as DriveEntryProto does not contain
 // the Drive file path (i.e. only contains the base name without parent
 // directory names).
 typedef base::Callback<void(GDataFileError error,
                             const FilePath& drive_file_path,
-                            scoped_ptr<GDataEntryProto> entry_proto)>
+                            scoped_ptr<DriveEntryProto> entry_proto)>
     GetEntryInfoWithFilePathCallback;
 
 // This is a part of EntryInfoPairResult.
 struct EntryInfoResult {
   EntryInfoResult();
   ~EntryInfoResult();
 
   FilePath path;
   GDataFileError error;
-  scoped_ptr<GDataEntryProto> proto;
+  scoped_ptr<DriveEntryProto> proto;
 };
 
 // The result of GetEntryInfoPairCallback(). Used to get a pair of entries
 // in one function call.
 struct EntryInfoPairResult {
   EntryInfoPairResult();
   ~EntryInfoPairResult();
 
   EntryInfoResult first;
   EntryInfoResult second;  // Only filled if the first entry is found.
@@ skipping 42 matching lines @@
   GDataFile* CreateGDataFile();
 
   // Creates a GDataDirectory instance.
   GDataDirectory* CreateGDataDirectory();
 
   // Sets root directory resource id and initialize the root entry.
   void InitializeRootEntry(const std::string& root_id);
 
   // Add |new entry| to |directory| and invoke the callback asynchronously.
   // |callback| may not be null.
-  // TODO(achuith,satorux): Use GDataEntryProto instead for new_entry.
+  // TODO(achuith,satorux): Use DriveEntryProto instead for new_entry.
   // crbug.com/142048
   void AddEntryToDirectory(GDataDirectory* directory,
                            GDataEntry* new_entry,
                            const FileMoveCallback& callback);
 
   // Moves |entry| to |directory_path| asynchronously. Removes entry from
   // previous parent. Must be called on UI thread. |callback| is called on the
   // UI thread. |callback| may not be null.
   void MoveEntryToDirectory(const FilePath& directory_path,
                             GDataEntry* entry,
@@ skipping 93 matching lines @@
       const std::string& serialized_proto);
 
   // Continues with GetEntryInfoPairByPaths after the first GDataEntry has been
   // asynchronously fetched. This fetches the second GDataEntry only if the
   // first was found.
   void GetEntryInfoPairByPathsAfterGetFirst(
       const FilePath& first_path,
       const FilePath& second_path,
       const GetEntryInfoPairCallback& callback,
       GDataFileError error,
-      scoped_ptr<GDataEntryProto> entry_proto);
+      scoped_ptr<DriveEntryProto> entry_proto);
 
   // Continues with GetIntroInfoPairByPaths after the second GDataEntry has been
   // asynchronously fetched.
   void GetEntryInfoPairByPathsAfterGetSecond(
       const FilePath& second_path,
       const GetEntryInfoPairCallback& callback,
       scoped_ptr<EntryInfoPairResult> result,
       GDataFileError error,
-      scoped_ptr<GDataEntryProto> entry_proto);
+      scoped_ptr<DriveEntryProto> entry_proto);
 
   // These internal functions need friend access to private GDataDirectory
   // methods.
   // Replaces file entry |old_entry| with its fresh value |fresh_file|.
   static void RefreshFileInternal(scoped_ptr<GDataFile> fresh_file,
                                   GDataEntry* old_entry);
 
   // Removes all child files of |directory| and replace with file_map.
   // |callback| may not be null.
   static void RefreshDirectoryInternal(const ResourceMap& file_map,
@@ skipping 17 matching lines @@
   // This should remain the last member so it'll be destroyed first and
   // invalidate its weak pointers before other members are destroyed.
   base::WeakPtrFactory<GDataDirectoryService> weak_ptr_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(GDataDirectoryService);
 };
 
 }  // namespace gdata
 
 #endif  // CHROME_BROWSER_CHROMEOS_GDATA_GDATA_DIRECTORY_SERVICE_H_