Move chrome.fileSystem implementation to //extensions

chrome/browser/extensions/api/file_system/consent_provider.cc

 // Copyright 2017 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/consent_provider.h"
 
 #include <memory>
 #include <string>
 
 #include "base/bind.h"
 #include "base/logging.h"
 #include "base/memory/ptr_util.h"
 #include "base/threading/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/volume_manager.h"
 #include "chrome/browser/extensions/api/file_system/request_file_system_notification.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/ui/views/extensions/request_file_system_dialog_view.h"
-#include "chrome/common/extensions/api/file_system.h"
 #include "components/user_manager/user_manager.h"
 #include "content/public/browser/render_frame_host.h"
 #include "content/public/browser/web_contents.h"
 #include "extensions/browser/app_window/app_window.h"
 #include "extensions/browser/app_window/app_window_registry.h"
+#include "extensions/common/api/file_system.h"
 #include "extensions/common/manifest_handlers/kiosk_mode_info.h"
 
 namespace extensions {
 
 namespace {
 
 // List of whitelisted component apps and extensions by their ids for
 // chrome.fileSystem.requestFileSystem.
 const char* const kRequestFileSystemComponentWhitelist[] = {
     file_manager::kFileManagerAppId,
@@ skipping 42 matching lines @@
 ConsentProvider::ConsentProvider(DelegateInterface* delegate)
     : delegate_(delegate) {
   DCHECK(delegate_);
 }
 
 ConsentProvider::~ConsentProvider() {
 }
 
 void ConsentProvider::RequestConsent(
     const Extension& extension,
+    content::RenderFrameHost* host,
     const base::WeakPtr<file_manager::Volume>& volume,
     bool writable,
     const ConsentCallback& callback) {
   DCHECK(IsGrantable(extension));
 
   // If a whitelisted component, then no need to ask or inform the user.
   if (extension.location() == Manifest::COMPONENT &&
       delegate_->IsWhitelistedComponent(extension)) {
     base::ThreadTaskRunnerHandle::Get()->PostTask(
         FROM_HERE, base::Bind(callback, CONSENT_GRANTED));
     return;
   }
 
   // If auto-launched kiosk app, then no need to ask user either, but show the
   // notification.
   if (delegate_->IsAutoLaunched(extension)) {
     delegate_->ShowNotification(extension, volume, writable);
     base::ThreadTaskRunnerHandle::Get()->PostTask(
         FROM_HERE, base::Bind(callback, CONSENT_GRANTED));
     return;
   }
 
   // If it's a kiosk app running in manual-launch kiosk session, then show
   // the confirmation dialog.
   if (KioskModeInfo::IsKioskOnly(&extension) &&
       user_manager::UserManager::Get()->IsLoggedInAsKioskApp()) {
-    delegate_->ShowDialog(extension, volume, writable,
+    delegate_->ShowDialog(extension, host, volume, writable,
                           base::Bind(&DialogResultToConsent, callback));
     return;
   }
 
   NOTREACHED() << "Cannot request consent for non-grantable extensions.";
 }
 
 bool ConsentProvider::IsGrantable(const Extension& extension) {
   const bool is_whitelisted_component =
       delegate_->IsWhitelistedComponent(extension);
 
   const bool is_running_in_kiosk_session =
       KioskModeInfo::IsKioskOnly(&extension) &&
       user_manager::UserManager::Get()->IsLoggedInAsKioskApp();
 
   return is_whitelisted_component || is_running_in_kiosk_session;
 }
 
-ConsentProviderDelegate::ConsentProviderDelegate(Profile* profile,
-                                                 content::RenderFrameHost* host)
-    : profile_(profile), host_(host) {
+ConsentProviderDelegate::ConsentProviderDelegate(Profile* profile)
+    : profile_(profile) {
   DCHECK(profile_);
 }
 
 ConsentProviderDelegate::~ConsentProviderDelegate() {
 }
 
 // static
 void ConsentProviderDelegate::SetAutoDialogButtonForTest(
     ui::DialogButton button) {
   g_auto_dialog_button_for_test = button;
 }
 
 void ConsentProviderDelegate::ShowDialog(
     const Extension& extension,
+    content::RenderFrameHost* host,
     const base::WeakPtr<file_manager::Volume>& volume,
     bool writable,
     const file_system_api::ConsentProvider::ShowDialogCallback& callback) {
-  DCHECK(host_);
+  DCHECK(host);
   content::WebContents* web_contents = nullptr;
 
   // Find an app window to host the dialog.
   content::WebContents* const foreground_contents =
-      content::WebContents::FromRenderFrameHost(host_);
+      content::WebContents::FromRenderFrameHost(host);
   if (AppWindowRegistry::Get(profile_)->GetAppWindowForWebContents(
           foreground_contents)) {
     web_contents = foreground_contents;
   }
 
   // If there is no web contents handle, then the method is most probably
   // executed from a background page.
   if (!web_contents)
     web_contents = GetWebContentsForAppId(profile_, extension.id());
 
@@ skipping 44 matching lines @@
     const Extension& extension) {
   for (auto* whitelisted_id : kRequestFileSystemComponentWhitelist) {
     if (extension.id().compare(whitelisted_id) == 0)
       return true;
   }
   return false;
 }
 
 }  // namespace file_system_api
 }  // namespace extensions