[File Manager] Add/remove Google Drive folder in the open File Manager when Drive enabled/disabled …

chrome/browser/chromeos/extensions/file_browser_private_api.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/chromeos/extensions/file_browser_private_api.h"
 
 #include <utility>
 
 #include "base/base64.h"
 #include "base/bind.h"
@@ skipping 161 matching lines @@
 
 
 // Gives the extension renderer |host| file |permissions| for the given |path|.
 void GrantFilePermissionsToHost(content::RenderViewHost* host,
                                 const FilePath& path,
                                 int permissions) {
   ChildProcessSecurityPolicy::GetInstance()->GrantPermissionsForFile(
       host->GetProcess()->GetID(), path, permissions);
 }
 
+void AddGDataMountPoint(
+    Profile* profile,
+    const std::string& extension_id,
+    content::RenderViewHost* render_view_host) {
+  fileapi::ExternalFileSystemMountPointProvider* provider =
+      BrowserContext::GetFileSystemContext(profile)->external_provider();
+  const FilePath mount_point = gdata::util::GetGDataMountPointPath();
+  if (!render_view_host || !render_view_host->GetProcess())
+    return;
+  if (!provider || provider->HasMountPoint(mount_point))
+    return;
+
+  // Grant R/W permissions to gdata 'folder'. File API layer still
+  // expects this to be satisfied.
+  GrantFilePermissionsToHost(render_view_host,
+                             mount_point,
+                             file_handler_util::GetReadWritePermissions());
+
+  // Grant R/W permission for tmp and pinned cache folder.
+  gdata::GDataSystemService* system_service =
+      gdata::GDataSystemServiceFactory::GetForProfile(profile);
+  // |system_service| is NULL if incognito window / guest login.
+  if (!system_service || !system_service->file_system())
+    return;
+  gdata::GDataFileSystem* gdata_file_system = system_service->file_system();
+
+  // We check permissions for raw cache file paths only for read-only
+  // operations (when fileEntry.file() is called), so read only permissions
+  // should be sufficient for all cache paths. For the rest of supported
+  // operations the file access check is done for drive/ paths.
+  GrantFilePermissionsToHost(render_view_host,
+                             gdata_file_system->GetCacheDirectoryPath(
+                                 gdata::GDataRootDirectory::CACHE_TYPE_TMP),
+                             file_handler_util::GetReadOnlyPermissions());
+  GrantFilePermissionsToHost(
+      render_view_host,
+      gdata_file_system->GetCacheDirectoryPath(
+          gdata::GDataRootDirectory::CACHE_TYPE_PERSISTENT),
+      file_handler_util::GetReadOnlyPermissions());
+
+  provider->AddRemoteMountPoint(
+      mount_point,
+      new gdata::GDataFileSystemProxy(gdata_file_system));
+
+  FilePath mount_point_virtual;
+  if (provider->GetVirtualPath(mount_point, &mount_point_virtual))
+    provider->GrantFileAccessToExtension(extension_id, mount_point_virtual);
+}
+
 // Given a file url, find the virtual FilePath associated with it.
 FilePath GetVirtualPathFromURL(const GURL& file_url) {
   FilePath virtual_path;
   fileapi::FileSystemType type = fileapi::kFileSystemTypeUnknown;
   GURL file_origin_url;
   if (!CrackFileSystemURL(file_url, &file_origin_url, &type, &virtual_path) ||
       type != fileapi::kFileSystemTypeExternal) {
     NOTREACHED();
     return FilePath();
   }
@@ skipping 129 matching lines @@
   return true;
 }
 
 void RequestLocalFileSystemFunction::RespondSuccessOnUIThread(
     const std::string& name, const GURL& root_path) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   // Add gdata mount point immediately when we kick of first instance of file
   // manager. The actual mount event will be sent to UI only when we perform
   // proper authentication.
   if (gdata::util::IsGDataAvailable(profile_))
-    AddGDataMountPoint();
+    AddGDataMountPoint(profile_, extension_id(), render_view_host());
   result_.reset(new DictionaryValue());
   DictionaryValue* dict = reinterpret_cast<DictionaryValue*>(result_.get());
   dict->SetString("name", name);
   dict->SetString("path", root_path.spec());
   dict->SetInteger("error", base::PLATFORM_FILE_OK);
   SendResponse(true);
 }
 
-void RequestLocalFileSystemFunction::AddGDataMountPoint() {
-  fileapi::ExternalFileSystemMountPointProvider* provider =
-      BrowserContext::GetFileSystemContext(profile_)->external_provider();
-  const FilePath mount_point = gdata::util::GetGDataMountPointPath();
-  if (!render_view_host() || !render_view_host()->GetProcess())
-    return;
-  if (!provider || provider->HasMountPoint(mount_point))
-    return;
-
-  // Grant R/W permissions to gdata 'folder'. File API layer still
-  // expects this to be satisfied.
-  GrantFilePermissionsToHost(render_view_host(),
-                             mount_point,
-                             file_handler_util::GetReadWritePermissions());
-
-  // Grant R/W permission for tmp and pinned cache folder.
-  gdata::GDataSystemService* system_service =
-      gdata::GDataSystemServiceFactory::GetForProfile(profile_);
-  // |system_service| is NULL if incognito window / guest login.
-  if (!system_service || !system_service->file_system())
-    return;
-  gdata::GDataFileSystem* gdata_file_system = system_service->file_system();
-
-  // We check permissions for raw cache file paths only for read-only
-  // operations (when fileEntry.file() is called), so read only permissions
-  // should be sufficient for all cache paths. For the rest of supported
-  // operations the file access check is done for drive/ paths.
-  GrantFilePermissionsToHost(render_view_host(),
-                             gdata_file_system->GetCacheDirectoryPath(
-                                 gdata::GDataRootDirectory::CACHE_TYPE_TMP),
-                             file_handler_util::GetReadOnlyPermissions());
-  GrantFilePermissionsToHost(
-      render_view_host(),
-      gdata_file_system->GetCacheDirectoryPath(
-          gdata::GDataRootDirectory::CACHE_TYPE_PERSISTENT),
-      file_handler_util::GetReadOnlyPermissions());
-
-  provider->AddRemoteMountPoint(
-      mount_point,
-      new gdata::GDataFileSystemProxy(gdata_file_system));
-
-  FilePath mount_point_virtual;
-  if (provider->GetVirtualPath(mount_point, &mount_point_virtual))
-    provider->GrantFileAccessToExtension(extension_id(), mount_point_virtual);
-}
-
 void RequestLocalFileSystemFunction::RespondFailedOnUIThread(
     base::PlatformFileError error_code) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   error_ = base::StringPrintf(kFileError, static_cast<int>(error_code));
   SendResponse(false);
 }
 
 bool FileWatchBrowserFunctionBase::GetLocalFilePath(
     const GURL& file_url, FilePath* local_path, FilePath* virtual_path) {
   GURL file_origin_url;
@@ skipping 1628 matching lines @@
     SendResponse(false);
   }
 }
 
 // Read GData-related preferences.
 bool GetGDataPreferencesFunction::RunImpl() {
   scoped_ptr<DictionaryValue> value(new DictionaryValue());
 
   const PrefService* service = profile_->GetPrefs();
 
+  bool driveEnabled = gdata::util::IsGDataAvailable(profile_);
+
+  if (driveEnabled)
+    AddGDataMountPoint(profile_, extension_id(), render_view_host());
+
+  value->SetBoolean("driveEnabled", driveEnabled);
+
   value->SetBoolean("cellularDisabled",
                     service->GetBoolean(prefs::kDisableGDataOverCellular));
 
   value->SetBoolean("hostedFilesDisabled",
                     service->GetBoolean(prefs::kDisableGDataHostedFiles));
 
   result_.reset(value.release());
   return true;
 }
 
@@ skipping 66 matching lines @@
   else if (active_network->type() == chromeos::TYPE_CELLULAR)
     type_string = "cellular";
   else
     type_string = "ethernet";  // Currently we do not care about other types.
 
   value->SetString("type", type_string);
   result_.reset(value.release());
 
   return true;
 }