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

chrome/browser/extensions/api/file_system/file_system_api_unittest.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 <vector>
 
 #include "base/files/file_path.h"
 #include "base/run_loop.h"
@@ skipping 67 matching lines @@
 #else
 #define ToStringType
 #endif
 
 #if defined(OS_CHROMEOS)
 class TestingConsentProviderDelegate
     : public ConsentProvider::DelegateInterface {
  public:
   TestingConsentProviderDelegate()
       : show_dialog_counter_(0),
+        show_notification_counter_(0),
         dialog_button_(ui::DIALOG_BUTTON_NONE),
         is_auto_launched_(false) {}
 
   ~TestingConsentProviderDelegate() {}
 
   // Sets a fake dialog response.
   void SetDialogButton(ui::DialogButton button) { dialog_button_ = button; }
 
   // Sets a fake result of detection the auto launch kiosk mode.
   void SetIsAutoLaunched(bool is_auto_launched) {
     is_auto_launched_ = is_auto_launched;
   }
 
   // Sets a whitelisted components list with a single id.
   void SetComponentWhitelist(const std::string& extension_id) {
     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,
-      base::WeakPtr<Volume> volume,
+      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 {
+    ++show_notification_counter_;
+  }
+
   bool IsAutoLaunched(const extensions::Extension& extension) override {
     return is_auto_launched_;
   }
 
   bool IsWhitelistedComponent(const extensions::Extension& extension) override {
     return whitelisted_component_id_.compare(extension.id()) == 0;
   }
 
   int show_dialog_counter_;
+  int show_notification_counter_;
   ui::DialogButton dialog_button_;
   bool is_auto_launched_;
   std::string whitelisted_component_id_;
 
   DISALLOW_COPY_AND_ASSIGN(TestingConsentProviderDelegate);
 };
 
 // Rewrites result of a consent request from |result| to |log|.
 void OnConsentReceived(ConsentProvider::Consent* log,
                        const ConsentProvider::Consent result) {
@@ skipping 185 matching lines @@
     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 */,
                             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.
   {
     scoped_refptr<Extension> non_component_extension(
         test_util::CreateEmptyExtension());
     TestingConsentProviderDelegate delegate;
     ConsentProvider provider(&delegate);
     EXPECT_FALSE(provider.IsGrantable(*non_component_extension));
   }
 }
 
 TEST_F(FileSystemApiConsentProviderTest, ForKioskApps) {
   // Non-component apps in auto-launch kiosk mode will be granted access
-  // instantly without asking for user consent.
+  // instantly without asking for user consent, but with a notification.
   {
     scoped_refptr<Extension> auto_launch_kiosk_app(
         test_util::BuildApp(ExtensionBuilder().Pass())
             .MergeManifest(DictionaryBuilder()
                                .SetBoolean("kiosk_enabled", true)
                                .SetBoolean("kiosk_only", true))
             .Build());
     user_manager_->AddKioskAppUser(auto_launch_kiosk_app->id());
     user_manager_->LoginUser(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_,
                             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().Pass())
           .MergeManifest(DictionaryBuilder()
                              .SetBoolean("kiosk_enabled", true)
                              .SetBoolean("kiosk_only", true))
           .Build());
   user_manager_->KioskAppLoggedIn(manual_launch_kiosk_app->id());
   {
     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_,
                             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_,
                             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);
   }
 }
 #endif
 
 }  // namespace extensions