drive: Rename 'gdata' namespace to 'drive' in chrome/browser/chromeos/drive

chrome/browser/ui/webui/chromeos/drive_internals_ui.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/ui/webui/chromeos/drive_internals_ui.h"
 
 #include "base/bind.h"
 #include "base/file_util.h"
 #include "base/format_macros.h"
 #include "base/memory/scoped_vector.h"
@@ skipping 87 matching lines @@
                       base::DictionaryValue* local_storage_summary) {
   DCHECK(!BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK(local_storage_summary);
 
   const int64 free_space = base::SysInfo::AmountOfFreeDiskSpace(home_path);
   local_storage_summary->SetDouble("free_space", free_space);
 }
 
 // Formats |entry| into text.
 std::string FormatEntry(const FilePath& path,
-                        const gdata::DriveEntryProto& entry) {
+                        const drive::DriveEntryProto& entry) {
   using base::StringAppendF;
   using gdata::util::FormatTimeAsString;
 
   std::string out;
   StringAppendF(&out, "%s\n", path.AsUTF8Unsafe().c_str());
   StringAppendF(&out, "  title: %s\n", entry.title().c_str());
   StringAppendF(&out, "  resource_id: %s\n", entry.resource_id().c_str());
   StringAppendF(&out, "  edit_url: %s\n", entry.edit_url().c_str());
   StringAppendF(&out, "  content_url: %s\n", entry.content_url().c_str());
   StringAppendF(&out, "  parent_resource_id: %s\n",
                 entry.parent_resource_id().c_str());
   StringAppendF(&out, "  upload_url: %s\n", entry.upload_url().c_str());
 
-  const gdata::PlatformFileInfoProto& file_info = entry.file_info();
+  const drive::PlatformFileInfoProto& file_info = entry.file_info();
   StringAppendF(&out, "  file_info\n");
   StringAppendF(&out, "    size: %"PRId64"\n", file_info.size());
   StringAppendF(&out, "    is_directory: %d\n", file_info.is_directory());
   StringAppendF(&out, "    is_symbolic_link: %d\n",
                 file_info.is_symbolic_link());
 
   const base::Time last_modified = base::Time::FromInternalValue(
       file_info.last_modified());
   const base::Time last_accessed = base::Time::FromInternalValue(
       file_info.last_accessed());
   const base::Time creation_time = base::Time::FromInternalValue(
       file_info.creation_time());
   StringAppendF(&out, "    last_modified: %s\n",
                 FormatTimeAsString(last_modified).c_str());
   StringAppendF(&out, "    last_accessed: %s\n",
                 FormatTimeAsString(last_accessed).c_str());
   StringAppendF(&out, "    creation_time: %s\n",
                 FormatTimeAsString(creation_time).c_str());
 
   if (entry.has_file_specific_info()) {
-    const gdata::DriveFileSpecificInfo& file_specific_info =
+    const drive::DriveFileSpecificInfo& file_specific_info =
         entry.file_specific_info();
     StringAppendF(&out, "    thumbnail_url: %s\n",
                   file_specific_info.thumbnail_url().c_str());
     StringAppendF(&out, "    alternate_url: %s\n",
                   file_specific_info.alternate_url().c_str());
     StringAppendF(&out, "    content_mime_type: %s\n",
                   file_specific_info.content_mime_type().c_str());
     StringAppendF(&out, "    file_md5: %s\n",
                   file_specific_info.file_md5().c_str());
     StringAppendF(&out, "    document_extension: %s\n",
@@ skipping 14 matching lines @@
   }
 
   virtual ~DriveInternalsWebUIHandler() {
   }
 
  private:
   // WebUIMessageHandler override.
   virtual void RegisterMessages() OVERRIDE;
 
   // Returns a DriveSystemService.
-  gdata::DriveSystemService* GetSystemService();
+  drive::DriveSystemService* GetSystemService();
 
   // Called when the page is first loaded.
   void OnPageLoaded(const base::ListValue* args);
 
   // Called when GetGCacheContents() is complete.
   void OnGetGCacheContents(base::ListValue* gcache_contents,
                            base::DictionaryValue* cache_summary);
 
   // Called when ReadDirectoryByPath() is complete.
   void OnReadDirectoryByPath(const FilePath& parent_path,
-                             gdata::DriveFileError error,
+                             drive::DriveFileError error,
                              bool hide_hosted_documents,
-                             scoped_ptr<gdata::DriveEntryProtoVector> entries);
+                             scoped_ptr<drive::DriveEntryProtoVector> entries);
 
   // Called when GetResourceIdsOfAllFilesOnUIThread() is complete.
   void OnGetResourceIdsOfAllFiles(
       const std::vector<std::string>& resource_ids);
 
   // Called when GetCacheEntryOnUIThread() is complete.
   void OnGetCacheEntry(const std::string& resource_id,
                        bool success,
-                       const gdata::DriveCacheEntry& cache_entry);
+                       const drive::DriveCacheEntry& cache_entry);
 
   // Called when GetFreeDiskSpace() is complete.
   void OnGetFreeDiskSpace(base::DictionaryValue* local_storage_summary);
 
   // Called when GetAccountMetadata() call to DriveService is complete.
   void OnGetAccountMetadata(gdata::GDataErrorCode status,
                             scoped_ptr<base::Value> data);
 
   // Called when the page requests periodic update.
   void OnPeriodicUpdate(const base::ListValue* args);
 
   // Updates the summary about in-flight operations.
   void UpdateInFlightOperations(
-      const gdata::DriveServiceInterface* drive_service);
+      const drive::DriveServiceInterface* drive_service);
 
   // The number of pending ReadDirectoryByPath() calls.
   int num_pending_reads_;
   base::WeakPtrFactory<DriveInternalsWebUIHandler> weak_ptr_factory_;
   DISALLOW_COPY_AND_ASSIGN(DriveInternalsWebUIHandler);
 };
 
 void DriveInternalsWebUIHandler::OnGetAccountMetadata(
     gdata::GDataErrorCode status, scoped_ptr<base::Value> data) {
   if (status != gdata::HTTP_SUCCESS) {
@@ skipping 51 matching lines @@
   web_ui()->RegisterMessageCallback(
       "pageLoaded",
       base::Bind(&DriveInternalsWebUIHandler::OnPageLoaded,
                  weak_ptr_factory_.GetWeakPtr()));
   web_ui()->RegisterMessageCallback(
       "periodicUpdate",
       base::Bind(&DriveInternalsWebUIHandler::OnPeriodicUpdate,
                  weak_ptr_factory_.GetWeakPtr()));
 }
 
-gdata::DriveSystemService* DriveInternalsWebUIHandler::GetSystemService() {
+drive::DriveSystemService* DriveInternalsWebUIHandler::GetSystemService() {
   Profile* profile = Profile::FromWebUI(web_ui());
-  return gdata::DriveSystemServiceFactory::GetForProfile(profile);
+  return drive::DriveSystemServiceFactory::GetForProfile(profile);
 }
 
 void DriveInternalsWebUIHandler::OnPageLoaded(const base::ListValue* args) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
-  gdata::DriveSystemService* system_service = GetSystemService();
+  drive::DriveSystemService* system_service = GetSystemService();
   // |system_service| may be NULL in the guest/incognito mode.
   if (!system_service)
     return;
 
-  gdata::DriveServiceInterface* drive_service = system_service->drive_service();
+  drive::DriveServiceInterface* drive_service = system_service->drive_service();
   DCHECK(drive_service);
 
   // Update the auth status section.
   base::DictionaryValue auth_status;
   auth_status.SetBoolean("has-refresh-token",
                          drive_service->HasRefreshToken());
   auth_status.SetBoolean("has-access-token",
                          drive_service->HasAccessToken());
   web_ui()->CallJavascriptFunction("updateAuthStatus", auth_status);
 
    // Update account metadata section.
   drive_service->GetAccountMetadata(
       base::Bind(&DriveInternalsWebUIHandler::OnGetAccountMetadata,
                  weak_ptr_factory_.GetWeakPtr()));
 
   // Start updating the GCache contents section.
   Profile* profile = Profile::FromWebUI(web_ui());
   const FilePath root_path =
-      gdata::DriveCache::GetCacheRootPath(profile);
+      drive::DriveCache::GetCacheRootPath(profile);
   base::ListValue* gcache_contents = new ListValue;
   base::DictionaryValue* gcache_summary = new DictionaryValue;
   BrowserThread::PostBlockingPoolTaskAndReply(
       FROM_HERE,
       base::Bind(&GetGCacheContents,
                  root_path,
                  gcache_contents,
                  gcache_summary),
       base::Bind(&DriveInternalsWebUIHandler::OnGetGCacheContents,
                  weak_ptr_factory_.GetWeakPtr(),
@@ skipping 18 matching lines @@
 void DriveInternalsWebUIHandler::OnGetGCacheContents(
     base::ListValue* gcache_contents,
     base::DictionaryValue* gcache_summary) {
   DCHECK(gcache_contents);
   DCHECK(gcache_summary);
   web_ui()->CallJavascriptFunction("updateGCacheContents",
                                    *gcache_contents,
                                    *gcache_summary);
 
   // Start updating the file system tree section, if we have access token.
-  gdata::DriveSystemService* system_service = GetSystemService();
+  drive::DriveSystemService* system_service = GetSystemService();
   if (!system_service->drive_service()->HasAccessToken())
     return;
 
   // Start rendering the file system tree as text.
-  const FilePath root_path = FilePath(gdata::kDriveRootDirectory);
+  const FilePath root_path = FilePath(drive::kDriveRootDirectory);
   ++num_pending_reads_;
   system_service->file_system()->ReadDirectoryByPath(
       root_path,
       base::Bind(&DriveInternalsWebUIHandler::OnReadDirectoryByPath,
                  weak_ptr_factory_.GetWeakPtr(),
                  root_path));
 }
 
 void DriveInternalsWebUIHandler::OnReadDirectoryByPath(
     const FilePath& parent_path,
-    gdata::DriveFileError error,
+    drive::DriveFileError error,
     bool hide_hosted_documents,
-    scoped_ptr<gdata::DriveEntryProtoVector> entries) {
+    scoped_ptr<drive::DriveEntryProtoVector> entries) {
   --num_pending_reads_;
-  if (error == gdata::DRIVE_FILE_OK) {
+  if (error == drive::DRIVE_FILE_OK) {
     DCHECK(entries.get());
 
     std::string file_system_as_text;
     for (size_t i = 0; i < entries->size(); ++i) {
-      const gdata::DriveEntryProto& entry = (*entries)[i];
+      const drive::DriveEntryProto& entry = (*entries)[i];
       const FilePath current_path = parent_path.Append(
           FilePath::FromUTF8Unsafe(entry.base_name()));
 
       file_system_as_text.append(FormatEntry(current_path, entry) + "\n");
 
       if (entry.file_info().is_directory()) {
         ++num_pending_reads_;
         GetSystemService()->file_system()->ReadDirectoryByPath(
             current_path,
             base::Bind(&DriveInternalsWebUIHandler::OnReadDirectoryByPath,
@@ skipping 27 matching lines @@
         "",  // Don't check MD5.
         base::Bind(&DriveInternalsWebUIHandler::OnGetCacheEntry,
                    weak_ptr_factory_.GetWeakPtr(),
                    resource_id));
   }
 }
 
 void DriveInternalsWebUIHandler::OnGetCacheEntry(
     const std::string& resource_id,
     bool success,
-    const gdata::DriveCacheEntry& cache_entry) {
+    const drive::DriveCacheEntry& cache_entry) {
   if (!success) {
     LOG(ERROR) << "Failed to get cache entry: " << resource_id;
     return;
   }
 
   // Convert |cache_entry| into a dictionary.
   base::DictionaryValue value;
   value.SetString("resource_id", resource_id);
   value.SetString("md5", cache_entry.md5());
   value.SetBoolean("is_present", cache_entry.is_present());
@@ skipping 10 matching lines @@
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK(local_storage_summary);
 
   web_ui()->CallJavascriptFunction(
       "updateLocalStorageUsage", *local_storage_summary);
 }
 
 void DriveInternalsWebUIHandler::OnPeriodicUpdate(const base::ListValue* args) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
-  gdata::DriveSystemService* system_service = GetSystemService();
+  drive::DriveSystemService* system_service = GetSystemService();
   // |system_service| may be NULL in the guest/incognito mode.
   if (!system_service)
     return;
 
-  gdata::DriveServiceInterface* drive_service = system_service->drive_service();
+  drive::DriveServiceInterface* drive_service = system_service->drive_service();
   DCHECK(drive_service);
 
   UpdateInFlightOperations(drive_service);
 }
 
 void DriveInternalsWebUIHandler::UpdateInFlightOperations(
-    const gdata::DriveServiceInterface* drive_service) {
+    const drive::DriveServiceInterface* drive_service) {
   gdata::OperationProgressStatusList
       progress_status_list = drive_service->GetProgressStatusList();
 
   base::ListValue in_flight_operations;
   for (size_t i = 0; i < progress_status_list.size(); ++i) {
     const gdata::OperationProgressStatus& status = progress_status_list[i];
 
     base::DictionaryValue* dict = new DictionaryValue;
     dict->SetInteger("operation_id", status.operation_id);
     dict->SetString(
@@ skipping 24 matching lines @@
       new ChromeWebUIDataSource(chrome::kChromeUIDriveInternalsHost);
   source->add_resource_path("drive_internals.css", IDR_DRIVE_INTERNALS_CSS);
   source->add_resource_path("drive_internals.js", IDR_DRIVE_INTERNALS_JS);
   source->set_default_resource(IDR_DRIVE_INTERNALS_HTML);
 
   Profile* profile = Profile::FromWebUI(web_ui);
   ChromeURLDataManager::AddDataSource(profile, source);
 }
 
 }  // namespace chromeos