Add the chrome.fileSystem.onVolumeListChanged event.

chrome/browser/extensions/api/file_system/file_system_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/extensions/api/file_system/file_system_api.h"
 
 #include <set>
 #include <vector>
 
 #include "apps/saved_files_service.h"
@@ skipping 52 matching lines @@
 #include "base/prefs/testing_pref_service.h"
 #include "base/strings/string16.h"
 #include "base/thread_task_runner_handle.h"
 #include "chrome/browser/chromeos/app_mode/kiosk_app_manager.h"
 #include "chrome/browser/chromeos/file_manager/app_id.h"
 #include "chrome/browser/chromeos/file_manager/filesystem_api_util.h"
 #include "chrome/browser/extensions/api/file_system/request_file_system_dialog_view.h"
 #include "chrome/browser/extensions/api/file_system/request_file_system_notification.h"
 #include "chrome/browser/ui/simple_message_box.h"
 #include "components/user_manager/user_manager.h"
+#include "extensions/browser/event_router.h"
+#include "extensions/browser/extension_registry.h"
 #include "extensions/common/constants.h"
 #include "extensions/common/manifest_handlers/kiosk_mode_info.h"
 #include "url/url_constants.h"
 #endif
 
 using apps::SavedFileEntry;
 using apps::SavedFilesService;
 using storage::IsolatedContext;
 
 const char kInvalidCallingPage[] = "Invalid calling page. This function can't "
@@ skipping 157 matching lines @@
 // with |app_id|. If not found, then returns NULL.
 content::WebContents* GetWebContentsForAppId(Profile* profile,
                                              const std::string& app_id) {
   extensions::AppWindowRegistry* const registry =
       extensions::AppWindowRegistry::Get(profile);
   DCHECK(registry);
   extensions::AppWindow* const app_window =
       registry->GetCurrentAppWindowForApp(app_id);
   return app_window ? app_window->web_contents() : nullptr;
 }
+
+// Fills a list of volumes mounted in the system.
+void FillVolumeList(
+    Profile* profile,
+    std::vector<linked_ptr<extensions::api::file_system::Volume>>* result) {
+  using file_manager::VolumeManager;
+  VolumeManager* const volume_manager = VolumeManager::Get(profile);
+  DCHECK(volume_manager);
+
+  using extensions::api::file_system::Volume;
+  const auto& volume_list = volume_manager->GetVolumeList();
+  // Convert volume_list to result_volume_list.
+  for (const auto& volume : volume_list) {
+    const linked_ptr<Volume> result_volume(new Volume);
+    result_volume->volume_id = volume->volume_id();
+    result_volume->writable = !volume->is_read_only();
+    result->push_back(result_volume);
+  }
+}
 #endif
 
 }  // namespace
 
 namespace extensions {
 
 namespace file_system_api {
 
 base::FilePath GetLastChooseEntryDirectory(const ExtensionPrefs* prefs,
                                            const std::string& extension_id) {
@@ skipping 19 matching lines @@
   std::vector<base::FilePath> graylisted_directories;
   for (size_t i = 0; i < arraysize(kGraylistedPaths); ++i) {
     base::FilePath graylisted_path;
     if (PathService::Get(kGraylistedPaths[i], &graylisted_path))
       graylisted_directories.push_back(graylisted_path);
   }
   return graylisted_directories;
 }
 
 #if defined(OS_CHROMEOS)
+void DispatchVolumeListChangeEvent(Profile* profile) {
+  DCHECK(profile);
+  EventRouter* const event_router = EventRouter::Get(profile);
+  if (!event_router)  // Possible on shutdown.
+    return;
+
+  extensions::ExtensionRegistry* const registry =
+      extensions::ExtensionRegistry::Get(profile);
+  if (!registry)  // Possible on shutdown.
+    return;
+
+  ConsentProvider consent_provider(
+      new ConsentProviderDelegate(profile, nullptr));
+  extensions::api::file_system::VolumeListChangedEvent event_args;
+  FillVolumeList(profile, &event_args.volumes);
+  for (const auto& extension : registry->enabled_extensions()) {
+    if (!consent_provider.IsGrantable(*extension.get()))
+      continue;
+    event_router->DispatchEventToExtension(
+        extension->id(),
+        make_scoped_ptr(new Event(
+            extensions::api::file_system::OnVolumeListChanged::kEventName,
+            extensions::api::file_system::OnVolumeListChanged::Create(
+                event_args))));
+  }
+}
+
 ConsentProvider::ConsentProvider(DelegateInterface* delegate)
     : delegate_(delegate) {
   DCHECK(delegate_);
 }
 
 ConsentProvider::~ConsentProvider() {
 }
 
 void ConsentProvider::RequestConsent(
     const extensions::Extension& extension,
@@ skipping 55 matching lines @@
     case ui::DIALOG_BUTTON_CANCEL:
       callback.Run(CONSENT_REJECTED);
       break;
   }
 }
 
 ConsentProviderDelegate::ConsentProviderDelegate(Profile* profile,
                                                  content::RenderViewHost* host)
     : profile_(profile), host_(host) {
   DCHECK(profile_);
-  DCHECK(host_);
 }
 
 ConsentProviderDelegate::~ConsentProviderDelegate() {
 }
 
 // static
 void ConsentProviderDelegate::SetAutoDialogButtonForTest(
     ui::DialogButton button) {
   g_auto_dialog_button_for_test = button;
 }
 
 void ConsentProviderDelegate::ShowDialog(
     const extensions::Extension& extension,
     const base::WeakPtr<file_manager::Volume>& volume,
     bool writable,
     const file_system_api::ConsentProvider::ShowDialogCallback& callback) {
+  DCHECK(host_);
   content::WebContents* const foreground_contents =
       GetWebContentsForRenderViewHost(profile_, host_);
   // If there is no web contents handle, then the method is most probably
   // executed from a background page. Find an app window to host the dialog.
   content::WebContents* const web_contents =
       foreground_contents ? foreground_contents
                           : GetWebContentsForAppId(profile_, extension.id());
   if (!web_contents) {
     base::ThreadTaskRunnerHandle::Get()->PostTask(
         FROM_HERE, base::Bind(callback, ui::DIALOG_BUTTON_NONE));
@@ skipping 1002 matching lines @@
 
 ExtensionFunction::ResponseAction FileSystemGetVolumeListFunction::Run() {
   // Only kiosk apps in kiosk sessions can use this API.
   // Additionally it is enabled for whitelisted component extensions and apps.
   file_system_api::ConsentProviderDelegate consent_provider_delegate(
       chrome_details_.GetProfile(), render_view_host());
   file_system_api::ConsentProvider consent_provider(&consent_provider_delegate);
 
   if (!consent_provider.IsGrantable(*extension()))
     return RespondNow(Error(kNotSupportedOnNonKioskSessionError));
-
-  using file_manager::VolumeManager;
-  VolumeManager* const volume_manager =
-      VolumeManager::Get(chrome_details_.GetProfile());
-  DCHECK(volume_manager);
-
   using extensions::api::file_system::Volume;
-  const auto& volume_list = volume_manager->GetVolumeList();
   std::vector<linked_ptr<Volume>> result_volume_list;
-  // Convert volume_list to result_volume_list.
-  for (const auto& volume : volume_list) {
-    const linked_ptr<Volume> result_volume(new Volume);
-    result_volume->volume_id = volume->volume_id();
-    result_volume->writable = !volume->is_read_only();
-    result_volume_list.push_back(result_volume);
-  }
+  FillVolumeList(chrome_details_.GetProfile(), &result_volume_list);
 
   return RespondNow(
       ArgumentList(extensions::api::file_system::GetVolumeList::Results::Create(
                        result_volume_list).Pass()));
 }
 #endif
 
 }  // namespace extensions