Reland 220012: Move the functions of filebrowserPrivateApi from the file_manager namespace to the e…

chrome/browser/chromeos/extensions/file_manager/private_api_drive.cc

 // Copyright 2013 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/chromeos/extensions/file_manager/private_api_drive.h"
 
 #include "base/prefs/pref_service.h"
 #include "base/strings/stringprintf.h"
 #include "chrome/browser/chromeos/drive/drive_app_registry.h"
 #include "chrome/browser/chromeos/drive/drive_integration_service.h"
 #include "chrome/browser/chromeos/drive/logging.h"
 #include "chrome/browser/chromeos/extensions/file_manager/file_tasks.h"
 #include "chrome/browser/chromeos/extensions/file_manager/private_api_util.h"
 #include "chrome/browser/chromeos/extensions/file_manager/url_util.h"
 #include "chrome/browser/chromeos/fileapi/file_system_backend.h"
 #include "chrome/browser/extensions/api/file_handlers/app_file_handler_util.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/common/pref_names.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/render_view_host.h"
 #include "webkit/common/fileapi/file_system_util.h"
 
 using content::BrowserThread;
 
-namespace file_manager {
+namespace extensions {
 namespace {
 
 // List of connection types of drive.
 // Keep this in sync with the DriveConnectionType in volume_manager.js.
 const char kDriveConnectionTypeOffline[] = "offline";
 const char kDriveConnectionTypeMetered[] = "metered";
 const char kDriveConnectionTypeOnline[] = "online";
 
 
 // List of reasons of kDriveConnectionType*.
@@ skipping 37 matching lines @@
 
 bool GetDriveEntryPropertiesFunction::RunImpl() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   std::string file_url_str;
   if (args_->GetSize() != 1 || !args_->GetString(0, &file_url_str))
     return false;
 
   GURL file_url = GURL(file_url_str);
   file_path_ = drive::util::ExtractDrivePath(
-      util::GetLocalPathFromURL(render_view_host(), profile(), file_url));
+      file_manager::util::GetLocalPathFromURL(
+          render_view_host(), profile(), file_url));
 
   properties_.reset(new base::DictionaryValue);
   properties_->SetString("fileUrl", file_url.spec());
 
   // Start getting the file info.
   drive::DriveIntegrationService* integration_service =
       drive::DriveIntegrationServiceFactory::GetForProfile(profile_);
   // |integration_service| is NULL if Drive is disabled.
   if (!integration_service) {
     CompleteGetFileProperties(drive::FILE_ERROR_FAILED);
@@ skipping 36 matching lines @@
 
   const drive::FileSpecificInfo& file_specific_info =
       entry->file_specific_info();
 
   // Get drive WebApps that can accept this file. We just need to extract the
   // doc icon for the drive app, which is set as default.
   ScopedVector<drive::DriveAppInfo> drive_apps;
   integration_service->drive_app_registry()->GetAppsForFile(
       file_path_, file_specific_info.content_mime_type(), &drive_apps);
   if (!drive_apps.empty()) {
-    std::string default_task_id = file_tasks::GetDefaultTaskIdFromPrefs(
-        profile_,
-        file_specific_info.content_mime_type(),
-        file_path_.Extension());
-    file_tasks::TaskDescriptor default_task;
-    file_tasks::ParseTaskID(default_task_id, &default_task);
+    std::string default_task_id =
+        file_manager::file_tasks::GetDefaultTaskIdFromPrefs(
+            profile_,
+            file_specific_info.content_mime_type(),
+            file_path_.Extension());
+    file_manager::file_tasks::TaskDescriptor default_task;
+    file_manager::file_tasks::ParseTaskID(default_task_id, &default_task);
     DCHECK(default_task_id.empty() || !default_task.app_id.empty());
     for (size_t i = 0; i < drive_apps.size(); ++i) {
       const drive::DriveAppInfo* app_info = drive_apps[i];
       if (default_task.app_id == app_info->app_id) {
         // The drive app is set as default. Files.app should use the doc icon.
-        const GURL doc_icon = util::FindPreferredIcon(app_info->document_icons,
-                                                      util::kPreferredIconSize);
+        const GURL doc_icon = file_manager::util::FindPreferredIcon(
+            app_info->document_icons,
+            file_manager::util::kPreferredIconSize);
         properties_->SetString("customIconUrl", doc_icon.spec());
       }
     }
   }
 
   integration_service->file_system()->GetCacheEntryByPath(
       file_path_,
       base::Bind(&GetDriveEntryPropertiesFunction::CacheStateReceived, this));
 }
 
@@ skipping 33 matching lines @@
     return false;
 
   drive::DriveIntegrationService* integration_service =
       drive::DriveIntegrationServiceFactory::GetForProfile(profile_);
   drive::FileSystemInterface* file_system =
       integration_service ? integration_service->file_system() : NULL;
   if (!file_system)  // |file_system| is NULL if Drive is disabled.
     return false;
 
   base::FilePath drive_path =
-      drive::util::ExtractDrivePath(
-          util::GetLocalPathFromURL(render_view_host(), profile(), GURL(url)));
+      drive::util::ExtractDrivePath(file_manager::util::GetLocalPathFromURL(
+          render_view_host(), profile(), GURL(url)));
   if (set_pin) {
     file_system->Pin(drive_path,
                      base::Bind(&PinDriveFileFunction::OnPinStateSet, this));
   } else {
     file_system->Unpin(drive_path,
                        base::Bind(&PinDriveFileFunction::OnPinStateSet, this));
   }
   return true;
 }
 
@@ skipping 18 matching lines @@
 bool GetDriveFilesFunction::RunImpl() {
   ListValue* file_urls_as_strings = NULL;
   if (!args_->GetList(0, &file_urls_as_strings))
     return false;
 
   // Convert the list of strings to a list of GURLs.
   for (size_t i = 0; i < file_urls_as_strings->GetSize(); ++i) {
     std::string file_url_as_string;
     if (!file_urls_as_strings->GetString(i, &file_url_as_string))
       return false;
-    const base::FilePath path = util::GetLocalPathFromURL(
+    const base::FilePath path = file_manager::util::GetLocalPathFromURL(
         render_view_host(), profile(), GURL(file_url_as_string));
     DCHECK(drive::util::IsUnderDriveMountPoint(path));
     base::FilePath drive_path = drive::util::ExtractDrivePath(path);
     remaining_drive_paths_.push(drive_path);
   }
 
   local_paths_ = new ListValue;
   GetFileOrSendResponse();
   return true;
 }
@@ skipping 79 matching lines @@
     if (drive::IsActiveFileTransferJobInfo(jobs[i]))
       path_to_id_map[jobs[i].file_path].push_back(jobs[i].job_id);
   }
 
   // Cancel by Job ID.
   scoped_ptr<ListValue> responses(new ListValue());
   for (size_t i = 0; i < url_list->GetSize(); ++i) {
     std::string url_as_string;
     url_list->GetString(i, &url_as_string);
 
-    base::FilePath file_path = util::GetLocalPathFromURL(
+    base::FilePath file_path = file_manager::util::GetLocalPathFromURL(
         render_view_host(), profile(), GURL(url_as_string));
     if (file_path.empty())
       continue;
 
     DCHECK(drive::util::IsUnderDriveMountPoint(file_path));
     file_path = drive::util::ExtractDrivePath(file_path);
     scoped_ptr<DictionaryValue> result(new DictionaryValue());
 
     // Cancel all the jobs for the file.
     PathToIdMap::iterator it = path_to_id_map.find(file_path);
@@ skipping 285 matching lines @@
 }
 
 GetShareUrlFunction::~GetShareUrlFunction() {
 }
 
 bool GetShareUrlFunction::RunImpl() {
   std::string file_url;
   if (!args_->GetString(0, &file_url))
     return false;
 
-  const base::FilePath path = util::GetLocalPathFromURL(
+  const base::FilePath path = file_manager::util::GetLocalPathFromURL(
       render_view_host(), profile(), GURL(file_url));
   DCHECK(drive::util::IsUnderDriveMountPoint(path));
 
   base::FilePath drive_path = drive::util::ExtractDrivePath(path);
 
   drive::DriveIntegrationService* integration_service =
       drive::DriveIntegrationServiceFactory::GetForProfile(profile_);
   // |integration_service| is NULL if Drive is disabled.
   if (!integration_service)
     return false;
 
   integration_service->file_system()->GetShareUrl(
       drive_path,
-      util::GetFileManagerBaseUrl(),  // embed origin
+      file_manager::util::GetFileManagerBaseUrl(),  // embed origin
       base::Bind(&GetShareUrlFunction::OnGetShareUrl, this));
   return true;
 }
 
 
 void GetShareUrlFunction::OnGetShareUrl(drive::FileError error,
                                         const GURL& share_url) {
   if (error != drive::FILE_ERROR_OK) {
     error_ = "Share Url for this item is not available.";
     SendResponse(false);
     return;
   }
 
   SetResult(new base::StringValue(share_url.spec()));
   SendResponse(true);
 }
 
-}  // namespace file_manager
+}  // namespace extensions