Add a policy to disable mounting of external storage.

chrome/browser/chromeos/extensions/file_browser_event_router.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_event_router.h"
 
 #include "base/bind.h"
 #include "base/json/json_writer.h"
 #include "base/message_loop.h"
 #include "base/stl_util.h"
@@ skipping 11 matching lines @@
 #include "chrome/browser/extensions/event_router.h"
 #include "chrome/browser/extensions/extension_service.h"
 #include "chrome/browser/prefs/pref_change_registrar.h"
 #include "chrome/browser/prefs/pref_service.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/profiles/profile_dependency_manager.h"
 #include "chrome/common/chrome_notification_types.h"
 #include "chrome/common/pref_names.h"
 #include "content/public/browser/notification_source.h"
 #include "grit/generated_resources.h"
+#include "ui/base/l10n/l10n_util.h"
 #include "webkit/fileapi/file_system_types.h"
 #include "webkit/fileapi/file_system_util.h"
 
 using chromeos::disks::DiskMountManager;
 using chromeos::disks::DiskMountManagerEventType;
 using content::BrowserThread;
 using gdata::GDataFileSystemInterface;
 using gdata::GDataSystemService;
 using gdata::GDataSystemServiceFactory;
 
@@ skipping 106 matching lines @@
 
   chromeos::NetworkLibrary* network_library =
       chromeos::CrosLibrary::Get()->GetNetworkLibrary();
   if (network_library)
      network_library->AddNetworkManagerObserver(this);
 
   pref_change_registrar_->Init(profile_->GetPrefs());
   pref_change_registrar_->Add(prefs::kDisableGDataOverCellular, this);
   pref_change_registrar_->Add(prefs::kDisableGDataHostedFiles, this);
   pref_change_registrar_->Add(prefs::kDisableGData, this);
+  pref_change_registrar_->Add(prefs::kExternalStorageDisabled, this);
 }
 
 // File watch setup routines.
 bool FileBrowserEventRouter::AddFileWatch(
     const FilePath& local_path,
     const FilePath& virtual_path,
     const std::string& extension_id) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::FILE));
 
   base::AutoLock lock(lock_);
@@ skipping 169 matching lines @@
 }
 
 void FileBrowserEventRouter::Observe(
     int type,
     const content::NotificationSource& source,
     const content::NotificationDetails& details) {
   if (!profile_ || !profile_->GetExtensionEventRouter()) {
     NOTREACHED();
     return;
   }
-  profile_->GetExtensionEventRouter()->DispatchEventToRenderers(
-      extensions::event_names::kOnFileBrowserGDataPreferencesChanged,
-      "[]", NULL, GURL());
+  if (type == chrome::NOTIFICATION_PREF_CHANGED) {
+    std::string* pref_name = content::Details<std::string>(details).ptr();
+    // If the policy just got disabled we have to unmount every device currently
+    // mounted. The opposite is fine - we can let the user re-plug her device to
+    // make it available.
+    if (*pref_name == prefs::kExternalStorageDisabled &&
+        profile_->GetPrefs()->GetBoolean(prefs::kExternalStorageDisabled)) {
+      DiskMountManager *manager = DiskMountManager::GetInstance();
+      DiskMountManager::MountPointMap mounts(manager->mount_points());
+      for (DiskMountManager::MountPointMap::const_iterator it = mounts.begin();
+           it != mounts.end(); ++it) {
+        LOG(INFO) << "Unmounting " << it->second.mount_path
+                  << " because of policy.";
+        manager->UnmountPath(it->second.mount_path);
+      }
+      return;
+    } else if (*pref_name == prefs::kDisableGDataOverCellular ||
+        *pref_name == prefs::kDisableGDataHostedFiles ||
+        *pref_name == prefs::kDisableGData) {
+      profile_->GetExtensionEventRouter()->DispatchEventToRenderers(
+          extensions::event_names::kOnFileBrowserGDataPreferencesChanged,
+          "[]", NULL, GURL());
+    }
+  }
 }
 
 void FileBrowserEventRouter::OnProgressUpdate(
     const std::vector<gdata::GDataOperationRegistry::ProgressStatus>& list) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   scoped_ptr<ListValue> event_list(
       file_manager_util::ProgressStatusVectorToListValue(
           profile_,
           file_manager_util::GetFileBrowserExtensionUrl().GetOrigin(),
@@ skipping 179 matching lines @@
 void FileBrowserEventRouter::OnDiskAdded(
     const DiskMountManager::Disk* disk) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   VLOG(1) << "Disk added: " << disk->device_path();
   if (disk->device_path().empty()) {
     VLOG(1) << "Empty system path for " << disk->device_path();
     return;
   }
 
-  // If disk is not mounted yet and it has media, give it a try.
-  if (disk->mount_path().empty() && disk->has_media()) {
+  // If disk is not mounted yet and it has media and there is no policy
+  // forbidding external storage, give it a try.
+  if (disk->mount_path().empty() && disk->has_media() &&
+      !profile_->GetPrefs()->GetBoolean(prefs::kExternalStorageDisabled)) {
     // Initiate disk mount operation. MountPath auto-detects the filesystem
     // format if the second argument is empty. The third argument (mount label)
     // is not used in a disk mount operation.
     DiskMountManager::GetInstance()->MountPath(
         disk->device_path(), std::string(), std::string(),
         chromeos::MOUNT_TYPE_DEVICE);
   } else {
     // Either the disk was mounted or it has no media. In both cases we don't
     // want the Scanning notification to persist.
     notifications_->HideNotification(FileBrowserNotifications::DEVICE,
@@ skipping 13 matching lines @@
   }
   DispatchDiskEvent(disk, false);
 }
 
 void FileBrowserEventRouter::OnDeviceAdded(
     const std::string& device_path) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   VLOG(1) << "Device added : " << device_path;
 
+  // If the policy is set instead of showing the new device notification we show
+  // a notification that the operation is not permitted.
+  if (profile_->GetPrefs()->GetBoolean(prefs::kExternalStorageDisabled)) {
+    notifications_->ShowNotificationWithMessage(
+        FileBrowserNotifications::DEVICE_FAIL,
+        device_path,
+        l10n_util::GetStringUTF16(IDS_EXTERNAL_STORAGE_DISABLED_MESSAGE));
+    return;
+  }
+
   notifications_->RegisterDevice(device_path);
   notifications_->ShowNotificationDelayed(FileBrowserNotifications::DEVICE,
                                           device_path,
                                           base::TimeDelta::FromSeconds(5));
 }
 
 void FileBrowserEventRouter::OnDeviceRemoved(
     const std::string& device_path) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
@@ skipping 183 matching lines @@
   return scoped_refptr<RefcountedProfileKeyedService>(
       new FileBrowserEventRouter(profile));
 }
 
 bool FileBrowserEventRouterFactory::ServiceHasOwnInstanceInIncognito() {
   // Explicitly and always allow this router in guest login mode.   see
   // chrome/browser/profiles/profile_keyed_base_factory.h comment
   // for the details.
   return true;
 }