Rename GDataDirectoryService to DriveResourceMetadata

chrome/browser/chromeos/gdata/drive_resource_metadata.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_
+#ifndef CHROME_BROWSER_CHROMEOS_GDATA_DRIVE_RESOURCE_METADATA_H_
+#define CHROME_BROWSER_CHROMEOS_GDATA_DRIVE_RESOURCE_METADATA_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 DriveDirectory;
 class DriveEntry;
 class DriveEntryProto;
 class DriveFile;
 class ResourceMetadataDB;
 
 typedef std::vector<DriveEntryProto> DriveEntryProtoVector;
 
 // File type on the gdata file system can be either a regular file or

[achuithb, 2012/08/22 09:41:06]

drive

[kochi, 2012/08/22 10:04:56]

Done.

 // a hosted document.
 enum DriveFileType {
   REGULAR_FILE,
   HOSTED_DOCUMENT,
 };
 
 // The root directory content origin.
 enum ContentOrigin {
   UNINITIALIZED,
   // Content is currently loading from somewhere.  Needs to wait.
   INITIALIZING,
   // Content is initialized, but during refreshing.
   REFRESHING,
   // Content is initialized from disk cache.
   FROM_CACHE,
   // Content is initialized from the direct server response.
   FROM_SERVER,
 };
 
 // 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");
+const FilePath::CharType kDriveRootDirectory[] = 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";
+const char kDriveRootDirectoryResourceId[] = "folder:root";
 
 // This should be incremented when incompatibility change is made in
 // drive.proto.
 const int32 kProtoVersion = 2;
 
 // 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, DriveEntry* entry)>
     FindEntryCallback;
 
@@ skipping 46 matching lines @@
 
   EntryInfoResult first;
   EntryInfoResult second;  // Only filled if the first entry is found.
 };
 
 // Used to receive the result from GetEntryInfoPairCallback().
 typedef base::Callback<void(scoped_ptr<EntryInfoPairResult> pair_result)>
     GetEntryInfoPairCallback;
 
 // Class to handle DriveEntry* lookups, add/remove DriveEntry*.
-class GDataDirectoryService {
+class DriveResourceMetadata {
  public:
   // Callback for GetEntryByResourceIdAsync.
   typedef base::Callback<void(DriveEntry* entry)> GetEntryByResourceIdCallback;
 
   // Map of resource id and serialized DriveEntry.
   typedef std::map<std::string, std::string> SerializedMap;
   // Map of resource id strings to DriveEntry*.
   typedef std::map<std::string, DriveEntry*> ResourceMap;
 
-  GDataDirectoryService();
-  ~GDataDirectoryService();
+  DriveResourceMetadata();
+  ~DriveResourceMetadata();
 
   DriveDirectory* root() { return root_.get(); }
 
   // Last time when we dumped serialized file system to disk.
   const base::Time& last_serialized() const { return last_serialized_; }
   void set_last_serialized(const base::Time& time) { last_serialized_ = time; }
   // Size of serialized file system on disk in bytes.
   const size_t serialized_size() const { return serialized_size_; }
   void set_serialized_size(size_t size) { serialized_size_ = size; }
 
@@ skipping 152 matching lines @@
                                   DriveEntry* 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,
                                        const FileMoveCallback& callback,
                                        DriveEntry* directory_entry);
 
   // Private data members.
   scoped_refptr<base::SequencedTaskRunner> blocking_task_runner_;
-  scoped_ptr<ResourceMetadataDB> directory_service_db_;
+  scoped_ptr<ResourceMetadataDB> resource_metadata_db_;
 
   ResourceMap resource_map_;
 
   scoped_ptr<DriveDirectory> root_;  // Stored in the serialized proto.
 
   base::Time last_serialized_;
   size_t serialized_size_;
   int64 largest_changestamp_;  // Stored in the serialized proto.
   ContentOrigin origin_;
 
   // 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_;
+  base::WeakPtrFactory<DriveResourceMetadata> weak_ptr_factory_;
 
-  DISALLOW_COPY_AND_ASSIGN(GDataDirectoryService);
+  DISALLOW_COPY_AND_ASSIGN(DriveResourceMetadata);
 };
 
 }  // namespace gdata
 
-#endif  // CHROME_BROWSER_CHROMEOS_GDATA_GDATA_DIRECTORY_SERVICE_H_
+#endif  // CHROME_BROWSER_CHROMEOS_GDATA_DRIVE_RESOURCE_METADATA_H_