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

chrome/browser/chromeos/extensions/file_manager/private_api_file_system.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_file_system.h"
 
 #include <sys/stat.h>
 #include <sys/statvfs.h>
 #include <sys/types.h>
 #include <utime.h>
@@ skipping 26 matching lines @@
 #include "webkit/common/fileapi/file_system_types.h"
 #include "webkit/common/fileapi/file_system_util.h"
 
 using chromeos::disks::DiskMountManager;
 using content::BrowserContext;
 using content::BrowserThread;
 using content::ChildProcessSecurityPolicy;
 using content::WebContents;
 using fileapi::FileSystemURL;
 
-namespace file_manager {
+namespace extensions {
 namespace {
 
 // Error messages.
 const char kFileError[] = "File error %d";
 
 const DiskMountManager::Disk* GetVolumeAsDisk(const std::string& mount_path) {
   DiskMountManager* disk_mount_manager = DiskMountManager::GetInstance();
 
   DiskMountManager::MountPointMap::const_iterator mount_point_it =
       disk_mount_manager->mount_points().find(mount_path);
   if (mount_point_it == disk_mount_manager->mount_points().end())
     return NULL;
 
   const DiskMountManager::Disk* disk = disk_mount_manager->FindDiskBySourcePath(
       mount_point_it->second.source_path);
 
   return (disk && disk->is_hidden()) ? NULL : disk;
 }
 
 base::DictionaryValue* CreateValueFromDisk(
     Profile* profile,
     const std::string& extension_id,
     const DiskMountManager::Disk* volume) {
   base::DictionaryValue* volume_info = new base::DictionaryValue();
 
   std::string mount_path;
   if (!volume->mount_path().empty()) {
     base::FilePath relative_mount_path;
-    util::ConvertAbsoluteFilePathToRelativeFileSystemPath(
+    file_manager::util::ConvertAbsoluteFilePathToRelativeFileSystemPath(
         profile, extension_id, base::FilePath(volume->mount_path()),
         &relative_mount_path);
     mount_path = relative_mount_path.value();
   }
 
   volume_info->SetString("devicePath", volume->device_path());
   volume_info->SetString("mountPath", mount_path);
   volume_info->SetString("systemPath", volume->system_path());
   volume_info->SetString("filePath", volume->file_path());
   volume_info->SetString("deviceLabel", volume->device_label());
@@ skipping 24 matching lines @@
 void SetDriveMountPointPermissions(
     Profile* profile,
     const std::string& extension_id,
     content::RenderViewHost* render_view_host) {
   if (!render_view_host ||
       !render_view_host->GetSiteInstance() || !render_view_host->GetProcess()) {
     return;
   }
 
   fileapi::ExternalFileSystemBackend* backend =
-      util::GetFileSystemContextForRenderViewHost(
+      file_manager::util::GetFileSystemContextForRenderViewHost(
           profile, render_view_host)->external_backend();
   if (!backend)
     return;
 
   const base::FilePath mount_point = drive::util::GetDriveMountPointPath();
   // Grant R/W permissions to drive 'folder'. File API layer still
   // expects this to be satisfied.
   ChildProcessSecurityPolicy::GetInstance()->GrantCreateReadWriteFile(
       render_view_host->GetProcess()->GetID(), mount_point);
 
@@ skipping 141 matching lines @@
 
 bool RequestFileSystemFunction::RunImpl() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   if (!dispatcher() || !render_view_host() || !render_view_host()->GetProcess())
     return false;
 
   set_log_on_completion(true);
 
   scoped_refptr<fileapi::FileSystemContext> file_system_context =
-      util::GetFileSystemContextForRenderViewHost(
+      file_manager::util::GetFileSystemContextForRenderViewHost(
           profile(), render_view_host());
 
   const GURL origin_url = source_url_.GetOrigin();
   file_system_context->OpenFileSystem(
       origin_url,
       fileapi::kFileSystemTypeExternal,
       fileapi::OPEN_FILE_SYSTEM_FAIL_IF_NONEXISTENT,
       base::Bind(&RequestFileSystemFunction::DidOpenFileSystem,
                  this,
                  file_system_context));
@@ skipping 18 matching lines @@
 
   if (!render_view_host() || !render_view_host()->GetProcess())
     return false;
 
   // First param is url of a file to watch.
   std::string url;
   if (!args_->GetString(0, &url) || url.empty())
     return false;
 
   scoped_refptr<fileapi::FileSystemContext> file_system_context =
-      util::GetFileSystemContextForRenderViewHost(
+      file_manager::util::GetFileSystemContextForRenderViewHost(
           profile(), render_view_host());
 
   FileSystemURL file_watch_url = file_system_context->CrackURL(GURL(url));
   base::FilePath local_path = file_watch_url.path();
   base::FilePath virtual_path = file_watch_url.virtual_path();
   if (local_path.empty()) {
     Respond(false);
     return true;
   }
   PerformFileWatchOperation(local_path, virtual_path, extension_id());
 
   return true;
 }
 
 AddFileWatchFunction::AddFileWatchFunction() {
 }
 
 AddFileWatchFunction::~AddFileWatchFunction() {
 }
 
 void AddFileWatchFunction::PerformFileWatchOperation(
     const base::FilePath& local_path,
     const base::FilePath& virtual_path,
     const std::string& extension_id) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
-  EventRouter* event_router =
-      FileBrowserPrivateAPI::Get(profile_)->event_router();
+  file_manager::EventRouter* event_router =
+      file_manager::FileBrowserPrivateAPI::Get(profile_)->event_router();
   event_router->AddFileWatch(
       local_path,
       virtual_path,
       extension_id,
       base::Bind(&AddFileWatchFunction::Respond, this));
 }
 
 RemoveFileWatchFunction::RemoveFileWatchFunction() {
 }
 
 RemoveFileWatchFunction::~RemoveFileWatchFunction() {
 }
 
 void RemoveFileWatchFunction::PerformFileWatchOperation(
     const base::FilePath& local_path,
     const base::FilePath& unused,
     const std::string& extension_id) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
-  EventRouter* event_router =
-      FileBrowserPrivateAPI::Get(profile_)->event_router();
+  file_manager::EventRouter* event_router =
+      file_manager::FileBrowserPrivateAPI::Get(profile_)->event_router();
   event_router->RemoveFileWatch(local_path, extension_id);
   Respond(true);
 }
 
 SetLastModifiedFunction::SetLastModifiedFunction() {
 }
 
 SetLastModifiedFunction::~SetLastModifiedFunction() {
 }
 
 bool SetLastModifiedFunction::RunImpl() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   if (args_->GetSize() != 2) {
     return false;
   }
 
   std::string file_url;
   if (!args_->GetString(0, &file_url))
     return false;
 
   std::string timestamp;
   if (!args_->GetString(1, &timestamp))
     return false;
 
-  base::FilePath local_path = util::GetLocalPathFromURL(
+  base::FilePath local_path = file_manager::util::GetLocalPathFromURL(
       render_view_host(), profile(), GURL(file_url));
 
   base::PostTaskAndReplyWithResult(
       BrowserThread::GetBlockingPool(),
       FROM_HERE,
       base::Bind(&SetLastModifiedOnBlockingPool,
                  local_path,
                  strtoul(timestamp.c_str(), NULL, 0)),
       base::Bind(&SetLastModifiedFunction::SendResponse,
                  this));
   return true;
 }
 
 GetSizeStatsFunction::GetSizeStatsFunction() {
 }
 
 GetSizeStatsFunction::~GetSizeStatsFunction() {
 }
 
 bool GetSizeStatsFunction::RunImpl() {
   if (args_->GetSize() != 1) {
     return false;
   }
 
   std::string mount_url;
   if (!args_->GetString(0, &mount_url))
     return false;
 
-  base::FilePath file_path = util::GetLocalPathFromURL(
+  base::FilePath file_path = file_manager::util::GetLocalPathFromURL(
       render_view_host(), profile(), GURL(mount_url));
   if (file_path.empty())
     return false;
 
   if (file_path == drive::util::GetDriveMountPointPath()) {
     drive::DriveIntegrationService* integration_service =
         drive::DriveIntegrationServiceFactory::GetForProfile(profile_);
     // |integration_service| is NULL if Drive is disabled.
     if (!integration_service) {
       // If stats couldn't be gotten for drive, result should be left
@@ skipping 64 matching lines @@
     error_ = "Invalid argument count";
     return false;
   }
 
   std::string volume_mount_url;
   if (!args_->GetString(0, &volume_mount_url)) {
     NOTREACHED();
     return false;
   }
 
-  base::FilePath file_path = util::GetLocalPathFromURL(
+  base::FilePath file_path = file_manager::util::GetLocalPathFromURL(
       render_view_host(), profile(), GURL(volume_mount_url));
   if (file_path.empty()) {
     error_ = "Invalid mount path.";
     return false;
   }
 
   results_.reset();
 
   base::FilePath home_path;
   // TODO(hidehiko): Return the volume info for Drive File System.
@@ skipping 20 matching lines @@
 bool ValidatePathNameLengthFunction::RunImpl() {
   std::string parent_url;
   if (!args_->GetString(0, &parent_url))
     return false;
 
   std::string name;
   if (!args_->GetString(1, &name))
     return false;
 
   scoped_refptr<fileapi::FileSystemContext> file_system_context =
-      util::GetFileSystemContextForRenderViewHost(
+      file_manager::util::GetFileSystemContextForRenderViewHost(
           profile(), render_view_host());
 
   fileapi::FileSystemURL filesystem_url(
       file_system_context->CrackURL(GURL(parent_url)));
   if (!chromeos::FileSystemBackend::CanHandleURL(filesystem_url))
     return false;
 
   // No explicit limit on the length of Drive file names.
   if (filesystem_url.type() == fileapi::kFileSystemTypeDrive) {
     SetResult(new base::FundamentalValue(true));
@@ skipping 28 matching lines @@
   if (args_->GetSize() != 1) {
     return false;
   }
 
   std::string volume_file_url;
   if (!args_->GetString(0, &volume_file_url)) {
     NOTREACHED();
     return false;
   }
 
-  base::FilePath file_path = util::GetLocalPathFromURL(
+  base::FilePath file_path = file_manager::util::GetLocalPathFromURL(
       render_view_host(), profile(), GURL(volume_file_url));
   if (file_path.empty())
     return false;
 
   DiskMountManager::GetInstance()->FormatMountedDevice(file_path.value());
   SendResponse(true);
   return true;
 }
 
-}  // namespace file_manager
+}  // namespace extensions