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 64 matching lines @@
 #if defined(OS_WIN)
 #define ToStringType base::UTF8ToWide
 #else
 #define ToStringType
 #endif
 
 #if defined(OS_CHROMEOS)
 // Registers a request for a user consent by incrementing the counter.
 // Additionally simulates completing the user consent request with the
 // |response| result.
-void OnUserConsentRequested(int* counter,
-                            const ConsentProvider::Consent response,
-                            const VolumeInfo& volume_info,
-                            bool writable,
-                            const ConsentProvider::ConsentCallback& callback) {
+void OnAskUser(int* counter,
+               const ConsentProvider::Consent response,
+               const VolumeInfo& volume_info,
+               bool writable,
+               const ConsentProvider::ConsentCallback& callback) {
   (*counter)++;
   callback.Run(response);
 }
 
+// Registers user notifications about auto-granting permissions.
+void OnNotifyUser(int* counter, const VolumeInfo& volume_info, bool writable) {
+  (*counter)++;
+}
+
 // Rewrites result of a consent request from |result| to |log|.
 void OnConsentReceived(ConsentProvider::Consent* log,
                        const ConsentProvider::Consent result) {
   *log = result;
 }
 
 // Returns a fake value whether an extension is auto launched or not.
 bool OnIsAutoLaunched(bool response, const Extension& extension) {
   return response;
 }
@@ skipping 160 matching lines @@
 #endif
 }
 
 #if defined(OS_CHROMEOS)
 TEST_F(FileSystemApiConsentProviderTest, ForNonKioskApps) {
   // Component apps are not granted unless they are whitelisted.
   {
     scoped_refptr<Extension> component_extension(
         test_util::BuildApp(ExtensionBuilder().SetLocation(Manifest::COMPONENT))
             .Build());
-    int user_consent_counter = 0;
-    ConsentProvider provider(base::Bind(&OnUserConsentRequested,
-                                        &user_consent_counter,
-                                        ConsentProvider::CONSENT_GRANTED));
+    int ask_user_counter = 0;
+    int notify_user_counter = 0;
+    ConsentProvider provider(base::Bind(&OnAskUser, &ask_user_counter,
+                                        ConsentProvider::CONSENT_GRANTED),
+                             base::Bind(&OnNotifyUser, &notify_user_counter));
     provider.SetIsAutoLaunchedForTesting(base::Bind(&OnIsAutoLaunched, false));
     EXPECT_FALSE(provider.IsGrantable(*component_extension));
 
     ConsentProvider::Consent result = ConsentProvider::CONSENT_IMPOSSIBLE;
     provider.RequestConsent(*component_extension.get(), volume_info_,
                             true /* writable */,
                             base::Bind(&OnConsentReceived, &result));
     base::RunLoop().RunUntilIdle();
 
-    EXPECT_EQ(0, user_consent_counter);
+    EXPECT_EQ(0, ask_user_counter);
+    EXPECT_EQ(0, notify_user_counter);
     EXPECT_EQ(ConsentProvider::CONSENT_REJECTED, result);
   }
 
   // Whitelitsted component apps are instantly granted access without asking
   // user.
   {
     scoped_refptr<Extension> whitelisted_component_extension(
         test_util::BuildApp(ExtensionBuilder().SetLocation(Manifest::COMPONENT))
             .Build());
-    int user_consent_counter = 0;
-    ConsentProvider provider(base::Bind(&OnUserConsentRequested,
-                                        &user_consent_counter,
-                                        ConsentProvider::CONSENT_REJECTED));
+    int ask_user_counter = 0;
+    int notify_user_counter = 0;
+    ConsentProvider provider(base::Bind(&OnAskUser, &ask_user_counter,
+                                        ConsentProvider::CONSENT_REJECTED),
+                             base::Bind(&OnNotifyUser, &notify_user_counter));
     std::set<std::string> whitelist;
     whitelist.insert(whitelisted_component_extension->id());
     provider.SetComponentWhitelistForTesting(whitelist);
     provider.SetIsAutoLaunchedForTesting(base::Bind(&OnIsAutoLaunched, false));
     EXPECT_TRUE(provider.IsGrantable(*whitelisted_component_extension));
 
     ConsentProvider::Consent result = ConsentProvider::CONSENT_IMPOSSIBLE;
     provider.RequestConsent(*whitelisted_component_extension.get(),
                             volume_info_, true /* writable */,
                             base::Bind(&OnConsentReceived, &result));
     base::RunLoop().RunUntilIdle();
 
-    EXPECT_EQ(0, user_consent_counter);
+    EXPECT_EQ(0, ask_user_counter);
+    EXPECT_EQ(0, notify_user_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());
-    int user_consent_counter = 0;
-    ConsentProvider provider(base::Bind(&OnUserConsentRequested,
-                                        &user_consent_counter,
-                                        ConsentProvider::CONSENT_GRANTED));
+    int ask_user_counter = 0;
+    int notify_user_counter = 0;
+    ConsentProvider provider(base::Bind(&OnAskUser, &ask_user_counter,
+                                        ConsentProvider::CONSENT_GRANTED),
+                             base::Bind(&OnNotifyUser, &notify_user_counter));
     provider.SetIsAutoLaunchedForTesting(base::Bind(&OnIsAutoLaunched, false));
     EXPECT_FALSE(provider.IsGrantable(*non_component_extension));
 
     ConsentProvider::Consent result = ConsentProvider::CONSENT_IMPOSSIBLE;
     provider.RequestConsent(*non_component_extension.get(), volume_info_,
                             true /* writable */,
                             base::Bind(&OnConsentReceived, &result));
     base::RunLoop().RunUntilIdle();
 
-    EXPECT_EQ(0, user_consent_counter);
+    EXPECT_EQ(0, ask_user_counter);
+    EXPECT_EQ(0, notify_user_counter);
     EXPECT_EQ(ConsentProvider::CONSENT_REJECTED, result);
   }
 }
 
 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());
 
-    int user_consent_counter = 0;
-    ConsentProvider provider(base::Bind(&OnUserConsentRequested,
-                                        &user_consent_counter,
-                                        ConsentProvider::CONSENT_REJECTED));
+    int ask_user_counter = 0;
+    int notify_user_counter = 0;
+    ConsentProvider provider(base::Bind(&OnAskUser, &ask_user_counter,
+                                        ConsentProvider::CONSENT_REJECTED),
+                             base::Bind(&OnNotifyUser, &notify_user_counter));
     provider.SetIsAutoLaunchedForTesting(base::Bind(&OnIsAutoLaunched, true));
     EXPECT_TRUE(provider.IsGrantable(*auto_launch_kiosk_app));
 
     ConsentProvider::Consent result = ConsentProvider::CONSENT_IMPOSSIBLE;
     provider.RequestConsent(*auto_launch_kiosk_app.get(), volume_info_,
                             true /* writable */,
                             base::Bind(&OnConsentReceived, &result));
     base::RunLoop().RunUntilIdle();
 
-    EXPECT_EQ(0, user_consent_counter);
+    EXPECT_EQ(0, ask_user_counter);
+    EXPECT_EQ(1, notify_user_counter);
     EXPECT_EQ(ConsentProvider::CONSENT_GRANTED, result);
   }
 
   // Non-component apps in manual-launch kiosk mode will be granted access after
   // receiving a user consent.
   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());
   {
-    int user_consent_counter = 0;
-    ConsentProvider provider(base::Bind(&OnUserConsentRequested,
-                                        &user_consent_counter,
-                                        ConsentProvider::CONSENT_GRANTED));
+    int ask_user_counter = 0;
+    int notify_user_counter = 0;
+    ConsentProvider provider(base::Bind(&OnAskUser, &ask_user_counter,
+                                        ConsentProvider::CONSENT_GRANTED),
+                             base::Bind(&OnNotifyUser, &notify_user_counter));
     provider.SetIsAutoLaunchedForTesting(base::Bind(&OnIsAutoLaunched, false));
     EXPECT_TRUE(provider.IsGrantable(*manual_launch_kiosk_app));
 
     ConsentProvider::Consent result = ConsentProvider::CONSENT_IMPOSSIBLE;
     provider.RequestConsent(*manual_launch_kiosk_app.get(), volume_info_,
                             true /* writable */,
                             base::Bind(&OnConsentReceived, &result));
     base::RunLoop().RunUntilIdle();
 
-    EXPECT_EQ(1, user_consent_counter);
+    EXPECT_EQ(1, ask_user_counter);
+    EXPECT_EQ(0, notify_user_counter);
     EXPECT_EQ(ConsentProvider::CONSENT_GRANTED, result);
   }
 
   // Non-component apps in manual-launch kiosk mode will be rejected access
   // after rejecting by a user.
   {
-    int user_consent_counter = 0;
-    ConsentProvider provider(base::Bind(&OnUserConsentRequested,
-                                        &user_consent_counter,
-                                        ConsentProvider::CONSENT_REJECTED));
+    int ask_user_counter = 0;
+    int notify_user_counter = 0;
+    ConsentProvider provider(base::Bind(&OnAskUser, &ask_user_counter,
+                                        ConsentProvider::CONSENT_REJECTED),
+                             base::Bind(&OnNotifyUser, &notify_user_counter));
     provider.SetIsAutoLaunchedForTesting(base::Bind(&OnIsAutoLaunched, false));
     EXPECT_TRUE(provider.IsGrantable(*manual_launch_kiosk_app));
 
     ConsentProvider::Consent result = ConsentProvider::CONSENT_IMPOSSIBLE;
     provider.RequestConsent(*manual_launch_kiosk_app.get(), volume_info_,
                             true /* writable */,
                             base::Bind(&OnConsentReceived, &result));
     base::RunLoop().RunUntilIdle();
 
-    EXPECT_EQ(1, user_consent_counter);
+    EXPECT_EQ(1, ask_user_counter);
+    EXPECT_EQ(0, notify_user_counter);
     EXPECT_EQ(ConsentProvider::CONSENT_REJECTED, result);
   }
 }
 #endif
 
 }  // namespace extensions