Rename GDataFileSystem* to DriveFileSystem*

chrome/browser/chromeos/gdata/drive_file_system.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_FILE_SYSTEM_H_
-#define CHROME_BROWSER_CHROMEOS_GDATA_GDATA_FILE_SYSTEM_H_
+#ifndef CHROME_BROWSER_CHROMEOS_GDATA_DRIVE_FILE_SYSTEM_H_
+#define CHROME_BROWSER_CHROMEOS_GDATA_DRIVE_FILE_SYSTEM_H_
 
 #include <map>
 #include <set>
 #include <string>
 #include <vector>
 
 #include "base/memory/scoped_ptr.h"
 #include "base/memory/weak_ptr.h"
 #include "base/observer_list.h"
 #include "base/platform_file.h"
 #include "base/timer.h"
 #include "chrome/browser/api/prefs/pref_change_registrar.h"
 #include "chrome/browser/chromeos/gdata/drive_cache.h"
+#include "chrome/browser/chromeos/gdata/drive_file_system_interface.h"
 #include "chrome/browser/chromeos/gdata/drive_resource_metadata.h"
 #include "chrome/browser/chromeos/gdata/gdata_errorcode.h"
-#include "chrome/browser/chromeos/gdata/gdata_file_system_interface.h"
 #include "chrome/browser/chromeos/gdata/gdata_wapi_feed_loader.h"
 #include "chrome/browser/chromeos/gdata/gdata_wapi_feed_processor.h"
 #include "content/public/browser/notification_observer.h"
 
 namespace base {
 class SequencedTaskRunner;
 }
 
 namespace gdata {
 
 class DriveServiceInterface;
 class DriveWebAppsRegistryInterface;
 class GDataUploaderInterface;
 class GDataWapiFeedLoader;
 struct UploadFileInfo;
 
-// The production implementation of GDataFileSystemInterface.
-class GDataFileSystem : public GDataFileSystemInterface,
+// The production implementation of DriveFileSystemInterface.
+class DriveFileSystem : public DriveFileSystemInterface,
                         public GDataWapiFeedLoader::Observer,
                         public content::NotificationObserver {
  public:
-  GDataFileSystem(Profile* profile,
+  DriveFileSystem(Profile* profile,
                   DriveCache* cache,
                   DriveServiceInterface* drive_service,
                   GDataUploaderInterface* uploader,
                   DriveWebAppsRegistryInterface* webapps_registry,
                   base::SequencedTaskRunner* blocking_task_runner);
-  virtual ~GDataFileSystem();
+  virtual ~DriveFileSystem();
 
-  // GDataFileSystem overrides.
+  // DriveFileSystem overrides.
   virtual void Initialize() OVERRIDE;
   virtual void AddObserver(
-      GDataFileSystemInterface::Observer* observer) OVERRIDE;
+      DriveFileSystemInterface::Observer* observer) OVERRIDE;
   virtual void RemoveObserver(
-      GDataFileSystemInterface::Observer* observer) OVERRIDE;
+      DriveFileSystemInterface::Observer* observer) OVERRIDE;
   virtual void StartUpdates() OVERRIDE;
   virtual void StopUpdates() OVERRIDE;
   virtual void NotifyFileSystemMounted() OVERRIDE;
   virtual void NotifyFileSystemToBeUnmounted() OVERRIDE;
   virtual void CheckForUpdates() OVERRIDE;
   virtual void GetEntryInfoByResourceId(
       const std::string& resource_id,
       const GetEntryInfoWithFilePathCallback& callback) OVERRIDE;
   virtual void Search(const std::string& search_query,
                       const GURL& next_feed,
@@ skipping 74 matching lines @@
   void LoadRootFeedFromCacheForTesting();
 
   // Used in tests to update the file system from |feed_list|.
   // See also the comment at GDataWapiFeedLoader::UpdateFromFeed().
   DriveFileError UpdateFromFeedForTesting(
       const std::vector<DocumentFeed*>& feed_list,
       int64 start_changestamp,
       int64 root_feed_changestamp);
 
  private:
-  friend class GDataFileSystemTest;
-  FRIEND_TEST_ALL_PREFIXES(GDataFileSystemTest,
+  friend class DriveFileSystemTest;
+  FRIEND_TEST_ALL_PREFIXES(DriveFileSystemTest,
                            FindFirstMissingParentDirectory);
 
   // Defines possible search results of FindFirstMissingParentDirectory().
   enum FindMissingDirectoryResult {
     // Target directory found, it's not a directory.
     FOUND_INVALID,
     // Found missing directory segment while searching for given directory.
     FOUND_MISSING,
     // Found target directory, it already exists.
     DIRECTORY_ALREADY_PRESENT,
@@ skipping 31 matching lines @@
   void TransferFileFromLocalToRemoteAfterGetEntryInfo(
       const FilePath& local_src_file_path,
       const FilePath& remote_dest_file_path,
       const FileOperationCallback& callback,
       DriveFileError error,
       scoped_ptr<DriveEntryProto> entry_proto);
 
   // Initiates transfer of |local_file_path| with |resource_id| to
   // |remote_dest_file_path|. |local_file_path| must be a file from the local
   // file system, |remote_dest_file_path| is the virtual destination path within
-  // gdata file system. If |resource_id| is a non-empty string, the transfer is
+  // Drive file system. If |resource_id| is a non-empty string, the transfer is
   // handled by CopyDocumentToDirectory. Otherwise, the transfer is handled by
   // TransferRegularFile.
   //
   // Must be called from *UI* thread. |callback| is run on the calling thread.
   // |callback| must not be null.
   void TransferFileForResourceId(const FilePath& local_file_path,
                                  const FilePath& remote_dest_file_path,
                                  const FileOperationCallback& callback,
                                  std::string* resource_id);
 
   // Initiates transfer of |local_file_path| to |remote_dest_file_path|.
   // |local_file_path| must be a regular file (i.e. not a hosted document) from
   // the local file system, |remote_dest_file_path| is the virtual destination
-  // path within gdata file system.
+  // path within Drive file system.
   //
   // Must be called from *UI* thread. |callback| is run on the calling thread.
   void TransferRegularFile(const FilePath& local_file_path,
                            const FilePath& remote_dest_file_path,
                            const FileOperationCallback& callback);
 
   // Invoked during the process of CreateFile.
   // First, FindEntryByPathAsyncOnUIThread is called and the result is returned
   // to OnGetEntryInfoForCreateFile. By using the information, CreateFile deals
   // with the cases when an entry already existed at the path. If there was no
@@ skipping 601 matching lines @@
   void CheckLocalModificationAndRunAfterGetFileInfo(
       scoped_ptr<DriveEntryProto> entry_proto,
       const GetEntryInfoCallback& callback,
       base::PlatformFileInfo* file_info,
       bool* get_file_info_result);
 
   // All members should be accessed only on UI thread. Do not post tasks to
   // other threads with base::Unretained(this).
   scoped_ptr<DriveResourceMetadata> resource_metadata_;
 
-  // The profile hosts the GDataFileSystem via GDataSystemService.
+  // The profile hosts the DriveFileSystem via GDataSystemService.
   Profile* profile_;
 
   // The cache owned by GDataSystemService.
   DriveCache* cache_;
 
   // The uploader owned by GDataSystemService.
   GDataUploaderInterface* uploader_;
 
   // The document service owned by GDataSystemService.
   DriveServiceInterface* drive_service_;
 
   // The webapps registry owned by GDataSystemService.
   DriveWebAppsRegistryInterface* webapps_registry_;
 
   // Periodic timer for checking updates.
   base::Timer update_timer_;
 
   // True if hosted documents should be hidden.
   bool hide_hosted_docs_;
 
   // The set of paths opened by OpenFile but not yet closed by CloseFile.
   std::set<FilePath> open_files_;
 
   scoped_ptr<PrefChangeRegistrar> pref_registrar_;
 
   // The loader is used to load the feeds.
   scoped_ptr<GDataWapiFeedLoader> feed_loader_;
 
-  ObserverList<GDataFileSystemInterface::Observer> observers_;
+  ObserverList<DriveFileSystemInterface::Observer> observers_;
 
   scoped_refptr<base::SequencedTaskRunner> blocking_task_runner_;
 
   // WeakPtrFactory and WeakPtr bound to the UI thread.
   // Note: These should remain the last member so they'll be destroyed and
   // invalidate the weak pointers before any other members are destroyed.
-  base::WeakPtrFactory<GDataFileSystem> ui_weak_ptr_factory_;
+  base::WeakPtrFactory<DriveFileSystem> ui_weak_ptr_factory_;
   // Unlike other classes, we need this as we need this to redirect a task
   // from IO thread to UI thread.
-  base::WeakPtr<GDataFileSystem> ui_weak_ptr_;
+  base::WeakPtr<DriveFileSystem> ui_weak_ptr_;
 };
 
 }  // namespace gdata
 
-#endif  // CHROME_BROWSER_CHROMEOS_GDATA_GDATA_FILE_SYSTEM_H_
+#endif  // CHROME_BROWSER_CHROMEOS_GDATA_DRIVE_FILE_SYSTEM_H_