Move chrome.fileSystem implementation to //extensions

chrome/browser/extensions/api/file_system/consent_provider_unittest.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 <string>
 
 #include "base/macros.h"
 #include "base/memory/ref_counted.h"
@@ skipping 42 matching lines @@
     whitelisted_component_id_ = extension_id;
   }
 
   int show_dialog_counter() const { return show_dialog_counter_; }
   int show_notification_counter() const { return show_notification_counter_; }
 
  private:
   // ConsentProvider::DelegateInterface overrides:
   void ShowDialog(
       const extensions::Extension& extension,
+      content::RenderFrameHost* host,
       const base::WeakPtr<Volume>& volume,
       bool writable,
       const ConsentProvider::ShowDialogCallback& callback) override {
     ++show_dialog_counter_;
     callback.Run(dialog_button_);
   }
 
   void ShowNotification(const extensions::Extension& extension,
                         const base::WeakPtr<Volume>& volume,
                         bool writable) override {
@@ skipping 73 matching lines @@
     scoped_refptr<Extension> whitelisted_component_extension(
         test_util::BuildApp(
             std::move(ExtensionBuilder().SetLocation(Manifest::COMPONENT)))
             .Build());
     TestingConsentProviderDelegate delegate;
     delegate.SetComponentWhitelist(whitelisted_component_extension->id());
     ConsentProvider provider(&delegate);
     EXPECT_TRUE(provider.IsGrantable(*whitelisted_component_extension));
 
     ConsentProvider::Consent result = ConsentProvider::CONSENT_IMPOSSIBLE;
-    provider.RequestConsent(*whitelisted_component_extension.get(), volume_,
-                            true /* writable */,
+    provider.RequestConsent(*whitelisted_component_extension.get(), nullptr,
+                            volume_, true /* writable */,
                             base::Bind(&OnConsentReceived, &result));
     base::RunLoop().RunUntilIdle();
 
     EXPECT_EQ(0, delegate.show_dialog_counter());
     EXPECT_EQ(0, delegate.show_notification_counter());
     EXPECT_EQ(ConsentProvider::CONSENT_GRANTED, result);
   }
 
   // Non-component apps in non-kiosk mode will be rejected instantly, without
   // asking for user consent.
@@ skipping 21 matching lines @@
         AccountId::FromUserEmail(auto_launch_kiosk_app->id()));
     user_manager_->LoginUser(
         AccountId::FromUserEmail(auto_launch_kiosk_app->id()));
 
     TestingConsentProviderDelegate delegate;
     delegate.SetIsAutoLaunched(true);
     ConsentProvider provider(&delegate);
     EXPECT_TRUE(provider.IsGrantable(*auto_launch_kiosk_app));
 
     ConsentProvider::Consent result = ConsentProvider::CONSENT_IMPOSSIBLE;
-    provider.RequestConsent(*auto_launch_kiosk_app.get(), volume_,
+    provider.RequestConsent(*auto_launch_kiosk_app.get(), nullptr, volume_,
                             true /* writable */,
                             base::Bind(&OnConsentReceived, &result));
     base::RunLoop().RunUntilIdle();
 
     EXPECT_EQ(0, delegate.show_dialog_counter());
     EXPECT_EQ(1, delegate.show_notification_counter());
     EXPECT_EQ(ConsentProvider::CONSENT_GRANTED, result);
   }
 
   // Non-component apps in manual-launch kiosk mode will be granted access after
   // receiving approval from the user.
   scoped_refptr<Extension> manual_launch_kiosk_app(
       test_util::BuildApp(ExtensionBuilder())
           .MergeManifest(DictionaryBuilder()
                              .SetBoolean("kiosk_enabled", true)
                              .SetBoolean("kiosk_only", true)
                              .Build())
           .Build());
   user_manager::User* const manual_kiosk_app_user =
       user_manager_->AddKioskAppUser(
           AccountId::FromUserEmail(manual_launch_kiosk_app->id()));
   user_manager_->KioskAppLoggedIn(manual_kiosk_app_user);
   {
     TestingConsentProviderDelegate delegate;
     delegate.SetDialogButton(ui::DIALOG_BUTTON_OK);
     ConsentProvider provider(&delegate);
     EXPECT_TRUE(provider.IsGrantable(*manual_launch_kiosk_app));
 
     ConsentProvider::Consent result = ConsentProvider::CONSENT_IMPOSSIBLE;
-    provider.RequestConsent(*manual_launch_kiosk_app.get(), volume_,
+    provider.RequestConsent(*manual_launch_kiosk_app.get(), nullptr, volume_,
                             true /* writable */,
                             base::Bind(&OnConsentReceived, &result));
     base::RunLoop().RunUntilIdle();
 
     EXPECT_EQ(1, delegate.show_dialog_counter());
     EXPECT_EQ(0, delegate.show_notification_counter());
     EXPECT_EQ(ConsentProvider::CONSENT_GRANTED, result);
   }
 
   // Non-component apps in manual-launch kiosk mode will be rejected access
   // after rejecting by a user.
   {
     TestingConsentProviderDelegate delegate;
     ConsentProvider provider(&delegate);
     delegate.SetDialogButton(ui::DIALOG_BUTTON_CANCEL);
     EXPECT_TRUE(provider.IsGrantable(*manual_launch_kiosk_app));
 
     ConsentProvider::Consent result = ConsentProvider::CONSENT_IMPOSSIBLE;
-    provider.RequestConsent(*manual_launch_kiosk_app.get(), volume_,
+    provider.RequestConsent(*manual_launch_kiosk_app.get(), nullptr, volume_,
                             true /* writable */,
                             base::Bind(&OnConsentReceived, &result));
     base::RunLoop().RunUntilIdle();
 
     EXPECT_EQ(1, delegate.show_dialog_counter());
     EXPECT_EQ(0, delegate.show_notification_counter());
     EXPECT_EQ(ConsentProvider::CONSENT_REJECTED, result);
   }
 }
 
 }  // namespace extensions