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

chrome/browser/ui/webui/feedback_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/feedback_ui.h"
 
 #include <algorithm>
 #include <vector>
 
 #include "base/bind.h"
@@ skipping 87 matching lines @@
 }
 
 std::string GetUserEmail() {
   chromeos::UserManager* manager = chromeos::UserManager::Get();
   if (!manager)
     return std::string();
   else
     return manager->GetLoggedInUser().display_email();
 }
 
-bool ScreenshotDriveTimestampComp(const gdata::DriveEntryProto& entry1,
-                                  const gdata::DriveEntryProto& entry2) {
+bool ScreenshotDriveTimestampComp(const drive::DriveEntryProto& entry1,
+                                  const drive::DriveEntryProto& entry2) {
   return entry1.file_info().last_modified() >
       entry2.file_info().last_modified();
 }
 
 void ReadDirectoryCallback(size_t max_saved,
                            std::vector<std::string>* saved_screenshots,
                            base::Closure callback,
-                           gdata::DriveFileError error,
+                           drive::DriveFileError error,
                            bool hide_hosted_documents,
-                           scoped_ptr<gdata::DriveEntryProtoVector> entries) {
-  if (error != gdata::DRIVE_FILE_OK) {
+                           scoped_ptr<drive::DriveEntryProtoVector> entries) {
+  if (error != drive::DRIVE_FILE_OK) {
     callback.Run();
     return;
   }
 
   size_t max_scan = std::min(kMaxNumScanFiles, entries->size());
-  std::vector<gdata::DriveEntryProto> screenshot_entries;
+  std::vector<drive::DriveEntryProto> screenshot_entries;
   for (size_t i = 0; i < max_scan; ++i) {
-    const gdata::DriveEntryProto& entry = (*entries)[i];
+    const drive::DriveEntryProto& entry = (*entries)[i];
     if (StartsWithASCII(entry.base_name(),
                         ScreenshotSource::kScreenshotPrefix, true) &&
         EndsWith(entry.base_name(),
                  ScreenshotSource::kScreenshotSuffix, true)) {
       screenshot_entries.push_back(entry);
     }
   }
 
   size_t sort_size = std::min(max_saved, screenshot_entries.size());
   std::partial_sort(screenshot_entries.begin(),
                     screenshot_entries.begin() + sort_size,
                     screenshot_entries.end(),
                     ScreenshotDriveTimestampComp);
   for (size_t i = 0; i < sort_size; ++i) {
-    const gdata::DriveEntryProto& entry = screenshot_entries[i];
+    const drive::DriveEntryProto& entry = screenshot_entries[i];
     saved_screenshots->push_back(
         std::string(ScreenshotSource::kScreenshotUrlRoot) +
         std::string(ScreenshotSource::kScreenshotSaved) +
         entry.resource_id());
   }
   callback.Run();
 }
 
 #else
 
@@ skipping 397 matching lines @@
 }
 
 #if defined(OS_CHROMEOS)
 void FeedbackHandler::HandleRefreshSavedScreenshots(const ListValue*) {
   std::vector<std::string>* saved_screenshots = new std::vector<std::string>;
   FilePath filepath = DownloadPrefs::FromBrowserContext(
       tab_->GetBrowserContext())->DownloadPath();
   base::Closure refresh_callback = base::Bind(
       &FeedbackHandler::RefreshSavedScreenshotsCallback,
       AsWeakPtr(), base::Owned(saved_screenshots));
-  if (gdata::util::IsUnderDriveMountPoint(filepath)) {
+  if (drive::util::IsUnderDriveMountPoint(filepath)) {
     GetMostRecentScreenshotsDrive(
         filepath, saved_screenshots, kMaxSavedScreenshots, refresh_callback);
   } else {
     BrowserThread::PostTaskAndReply(
         BrowserThread::FILE, FROM_HERE,
         base::Bind(&FeedbackUI::GetMostRecentScreenshots, filepath,
                    base::Unretained(saved_screenshots), kMaxSavedScreenshots),
         refresh_callback);
   }
 }
 
 void FeedbackHandler::RefreshSavedScreenshotsCallback(
     std::vector<std::string>* saved_screenshots) {
   ListValue screenshots_list;
   for (size_t i = 0; i < saved_screenshots->size(); ++i)
     screenshots_list.Append(new StringValue((*saved_screenshots)[i]));
   web_ui()->CallJavascriptFunction("setupSavedScreenshots", screenshots_list);
 }
 
 void FeedbackHandler::GetMostRecentScreenshotsDrive(
     const FilePath& filepath, std::vector<std::string>* saved_screenshots,
     size_t max_saved, base::Closure callback) {
-  gdata::DriveFileSystemInterface* file_system =
-      gdata::DriveSystemServiceFactory::GetForProfile(
+  drive::DriveFileSystemInterface* file_system =
+      drive::DriveSystemServiceFactory::GetForProfile(
           Profile::FromWebUI(web_ui()))->file_system();
   file_system->ReadDirectoryByPath(
-      gdata::util::ExtractDrivePath(filepath),
+      drive::util::ExtractDrivePath(filepath),
       base::Bind(&ReadDirectoryCallback, max_saved, saved_screenshots,
                  callback));
 }
 #endif
 
 
 void FeedbackHandler::HandleSendReport(const ListValue* list_value) {
   if (!feedback_data_) {
     LOG(ERROR) << "Bug report hasn't been intialized yet.";
     return;
@@ skipping 148 matching lines @@
                     screenshot_filepaths.begin() + sort_size,
                     screenshot_filepaths.end(),
                     ScreenshotTimestampComp);
   for (size_t i = 0; i < sort_size; ++i)
     saved_screenshots->push_back(
                     std::string(ScreenshotSource::kScreenshotUrlRoot) +
                     std::string(ScreenshotSource::kScreenshotSaved) +
                     screenshot_filepaths[i]);
 }
 #endif