Add a notification about auto-granted access to file systems.

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 49 matching lines @@
 #endif
 
 #if defined(OS_CHROMEOS)
 #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/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;
@@ skipping 193 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)
-ConsentProvider::ConsentProvider(
-    const UserConsentRequestCallback& user_consent_request_callback)
-    : user_consent_request_callback_(user_consent_request_callback),
+ConsentProvider::ConsentProvider(const AskUserCallback& ask_user_callback,
+                                 const NotifyUserCallback& notify_user_callback)
+    : ask_user_callback_(ask_user_callback),
+      notify_user_callback_(notify_user_callback),
       is_auto_launched_callback_(base::Bind(&ConsentProvider::IsAutoLaunched,
                                             base::Unretained(this))) {
   for (const auto& whitelisted_id : kRequestFileSystemComponentWhitelist)
     component_whitelist_.insert(whitelisted_id);
 }
 
 ConsentProvider::ConsentProvider()
     : is_auto_launched_callback_(base::Bind(&ConsentProvider::IsAutoLaunched,
                                             base::Unretained(this))) {
   for (const auto& whitelisted_id : kRequestFileSystemComponentWhitelist)
     component_whitelist_.insert(whitelisted_id);
 }
 
 ConsentProvider::~ConsentProvider() {
 }
 
 void ConsentProvider::RequestConsent(
     const extensions::Extension& extension,
     const file_manager::VolumeInfo& volume_info,
     bool writable,
     const ConsentCallback& callback) {
   if (!IsGrantable(extension)) {
     base::ThreadTaskRunnerHandle::Get()->PostTask(
         FROM_HERE, base::Bind(callback, CONSENT_REJECTED));
     return;
   }
 
   const bool is_auto_launched = is_auto_launched_callback_.Run(extension);
-  const bool requires_consent =
-      !is_auto_launched && extension.location() != Manifest::COMPONENT;
 
-  if (!requires_consent) {
-    // Grant the permission without showing the dialog.
+  if (extension.location() == Manifest::COMPONENT) {
+    // Grant the permission without showing the dialog or notification.
     base::ThreadTaskRunnerHandle::Get()->PostTask(
         FROM_HERE, base::Bind(callback, CONSENT_GRANTED));
-  } else {
-    DCHECK(!user_consent_request_callback_.is_null());
+    return;
+  } else if (is_auto_launched) {
+    // Grant the permission without showing the dialog, but with a notification.
+    DCHECK(!notify_user_callback_.is_null());
     base::ThreadTaskRunnerHandle::Get()->PostTask(
-        FROM_HERE, base::Bind(user_consent_request_callback_, volume_info,
-                              writable, callback));
+        FROM_HERE, base::Bind(notify_user_callback_, volume_info, writable));
+    base::ThreadTaskRunnerHandle::Get()->PostTask(
+        FROM_HERE, base::Bind(callback, CONSENT_GRANTED));
+    return;
   }
+
+  // By default ask for user consent.
+  DCHECK(!ask_user_callback_.is_null());
+  base::ThreadTaskRunnerHandle::Get()->PostTask(
+      FROM_HERE,
+      base::Bind(ask_user_callback_, volume_info, writable, callback));
 }
 
 bool ConsentProvider::IsGrantable(const Extension& extension) {
   bool is_whitelisted_component =
       component_whitelist_.find(extension.id()) != component_whitelist_.end();
 
   const bool is_running_in_kiosk_session =
       KioskModeInfo::IsKioskOnly(&extension) &&
       user_manager::UserManager::Get()->IsLoggedInAsKioskApp();
 
@@ skipping 788 matching lines @@
 
 bool FileSystemGetObservedEntriesFunction::RunSync() {
   NOTIMPLEMENTED();
   error_ = kUnknownIdError;
   return false;
 }
 
 FileSystemRequestFileSystemFunction::FileSystemRequestFileSystemFunction()
     : chrome_details_(this) {
 #if defined(OS_CHROMEOS)
-  consent_provider_.reset(new ConsentProvider(base::Bind(
-      &FileSystemRequestFileSystemFunction::OnUserConsentRequested, this)));
+  consent_provider_.reset(new ConsentProvider(
+      base::Bind(&FileSystemRequestFileSystemFunction::OnAskUser, this),
+      base::Bind(&FileSystemRequestFileSystemFunction::OnNotifyUser, this)));
 #endif
 }
 
 FileSystemRequestFileSystemFunction::~FileSystemRequestFileSystemFunction() {
 }
 
 ExtensionFunction::ResponseAction FileSystemRequestFileSystemFunction::Run() {
   using extensions::api::file_system::RequestFileSystem::Params;
   const scoped_ptr<Params> params(Params::Create(*args_));
   EXTENSION_FUNCTION_VALIDATE(params);
@@ skipping 56 matching lines @@
 ui::DialogButton
     FileSystemRequestFileSystemFunction::auto_dialog_button_for_testing_ =
         ui::DIALOG_BUTTON_NONE;
 
 // static
 void FileSystemRequestFileSystemFunction::SetAutoDialogButtonForTesting(
     ui::DialogButton button) {
   FileSystemRequestFileSystemFunction::auto_dialog_button_for_testing_ = button;
 }
 
-void FileSystemRequestFileSystemFunction::OnUserConsentRequested(
+void FileSystemRequestFileSystemFunction::OnAskUser(
     const file_manager::VolumeInfo& volume_info,
     bool writable,
     const ConsentProvider::ConsentCallback& callback) {
   // The object deletes itself once the dialog is closed.
   content::WebContents* const foreground_contents =
       GetWebContentsForRenderViewHost(chrome_details_.GetProfile(),
                                       render_view_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 =
@@ skipping 17 matching lines @@
     return;
   }
 
   RequestFileSystemDialogView::ShowDialog(
       web_contents, *extension(), volume_info, writable,
       base::Bind(
           &FileSystemRequestFileSystemFunction::OnUserConsentDialogClosed, this,
           callback));
 }
 
+void FileSystemRequestFileSystemFunction::OnNotifyUser(
+    const file_manager::VolumeInfo& volume_info,
+    bool writable) {
+  RequestFileSystemNotification::ShowAutoGrantedNotification(
+      chrome_details_.GetProfile(), *extension(), volume_info, writable);
+}
+
 void FileSystemRequestFileSystemFunction::OnUserConsentDialogClosed(
     const ConsentProvider::ConsentCallback& callback,
     ui::DialogButton result) {
   callback.Run(result == ui::DIALOG_BUTTON_OK
                    ? ConsentProvider::CONSENT_GRANTED
                    : ConsentProvider::CONSENT_REJECTED);
 }
 
 void FileSystemRequestFileSystemFunction::OnConsentReceived(
     const std::string& volume_id,
@@ skipping 145 matching lines @@
     volume_list.push_back(volume);
   }
 
   return RespondNow(
       ArgumentList(extensions::api::file_system::GetVolumeList::Results::Create(
                        volume_list).Pass()));
 #endif
 }
 
 }  // namespace extensions