Home | History | Annotate | Download | only in extensions 
      1 // Copyright 2014 The Chromium Authors. All rights reserved.
      2 // Use of this source code is governed by a BSD-style license that can be
      3 // found in the LICENSE file.
      4 
      5 #include <set>
      6 
      7 #include "base/run_loop.h"
      8 #include "base/strings/string_number_conversions.h"
      9 #include "chrome/browser/extensions/extension_browsertest.h"
     10 #include "chrome/browser/extensions/extension_service.h"
     11 #include "chrome/browser/extensions/extension_storage_monitor.h"
     12 #include "chrome/browser/extensions/extension_test_message_listener.h"
     13 #include "chrome/browser/ui/extensions/application_launch.h"
     14 #include "content/public/test/test_utils.h"
     15 #include "extensions/browser/extension_prefs.h"
     16 #include "extensions/browser/extension_system.h"
     17 #include "ui/message_center/message_center.h"
     18 #include "ui/message_center/message_center_observer.h"
     19 
     20 namespace extensions {
     21 
     22 namespace {
     23 
     24 const int kInitialUsageThreshold = 500;
     25 
     26 const char kWriteDataApp[] = "storage_monitor/write_data";
     27 
     28 class NotificationObserver : public message_center::MessageCenterObserver {
     29  public:
     30   explicit NotificationObserver(const std::string& target_notification)
     31       : message_center_(message_center::MessageCenter::Get()),
     32         target_notification_id_(target_notification),
     33         waiting_(false) {
     34     message_center_->AddObserver(this);
     35   }
     36 
     37   virtual ~NotificationObserver() {
     38     message_center_->RemoveObserver(this);
     39   }
     40 
     41   bool HasReceivedNotification() const {
     42     return received_notifications_.find(target_notification_id_) !=
     43       received_notifications_.end();
     44   }
     45 
     46   // Runs the message loop and returns true if a notification is received.
     47   // Immediately returns true if a notification has already been received.
     48   bool WaitForNotification() {
     49     if (HasReceivedNotification())
     50       return true;
     51 
     52     waiting_ = true;
     53     content::RunMessageLoop();
     54     waiting_ = false;
     55     return HasReceivedNotification();
     56   }
     57 
     58  private:
     59   // MessageCenterObserver implementation:
     60   virtual void OnNotificationAdded(
     61       const std::string& notification_id) OVERRIDE {
     62     received_notifications_.insert(notification_id);
     63 
     64     if (waiting_ && HasReceivedNotification())
     65       base::MessageLoopForUI::current()->Quit();
     66   }
     67 
     68   message_center::MessageCenter* message_center_;
     69   std::set<std::string> received_notifications_;
     70   std::string target_notification_id_;
     71   bool waiting_;
     72 };
     73 
     74 }  // namespace
     75 
     76 class ExtensionStorageMonitorTest : public ExtensionBrowserTest {
     77  public:
     78   ExtensionStorageMonitorTest() : storage_monitor_(NULL) {}
     79 
     80  protected:
     81   // ExtensionBrowserTest overrides:
     82   virtual void SetUpOnMainThread() OVERRIDE {
     83     ExtensionBrowserTest::SetUpOnMainThread();
     84 
     85     InitStorageMonitor();
     86   }
     87 
     88   ExtensionStorageMonitor* monitor() {
     89     CHECK(storage_monitor_);
     90     return storage_monitor_;
     91   }
     92 
     93   int64 GetInitialExtensionThreshold() {
     94     CHECK(storage_monitor_);
     95     return storage_monitor_->initial_extension_threshold_;
     96   }
     97 
     98   int64 GetInitialEphemeralThreshold() {
     99     CHECK(storage_monitor_);
    100     return storage_monitor_->initial_ephemeral_threshold_;
    101   }
    102 
    103   void DisableForInstalledExtensions() {
    104     CHECK(storage_monitor_);
    105     storage_monitor_->enable_for_all_extensions_ = false;
    106   }
    107 
    108   const Extension* InitWriteDataApp() {
    109     base::FilePath path = test_data_dir_.AppendASCII(kWriteDataApp);
    110     const Extension* extension = InstallExtension(path, 1);
    111     EXPECT_TRUE(extension);
    112     return extension;
    113   }
    114 
    115   const Extension* InitWriteDataEphemeralApp() {
    116     // The threshold for installed extensions should be higher than ephemeral
    117     // apps.
    118     storage_monitor_->initial_extension_threshold_ =
    119         storage_monitor_->initial_ephemeral_threshold_ * 4;
    120 
    121     base::FilePath path = test_data_dir_.AppendASCII(kWriteDataApp);
    122     const Extension* extension = InstallEphemeralAppWithSourceAndFlags(
    123         path, 1, Manifest::INTERNAL, Extension::NO_FLAGS);
    124     EXPECT_TRUE(extension);
    125     return extension;
    126   }
    127 
    128   std::string GetNotificationId(const std::string& extension_id) {
    129     return monitor()->GetNotificationId(extension_id);
    130   }
    131 
    132   bool IsStorageNotificationEnabled(const std::string& extension_id) {
    133     return monitor()->IsStorageNotificationEnabled(extension_id);
    134   }
    135 
    136   int64 GetNextStorageThreshold(const std::string& extension_id) {
    137     return monitor()->GetNextStorageThreshold(extension_id);
    138   }
    139 
    140   void WriteBytesExpectingNotification(const Extension* extension,
    141                                        int num_bytes) {
    142     int64 previous_threshold = GetNextStorageThreshold(extension->id());
    143     WriteBytes(extension, num_bytes, true);
    144     EXPECT_GT(GetNextStorageThreshold(extension->id()), previous_threshold);
    145   }
    146 
    147   void WriteBytesNotExpectingNotification(const Extension* extension,
    148                                          int num_bytes) {
    149     WriteBytes(extension, num_bytes, false);
    150   }
    151 
    152   void SimulateUninstallDialogAccept() {
    153     // Ensure the uninstall dialog was shown and fake an accept.
    154     ASSERT_TRUE(monitor()->uninstall_dialog_.get());
    155     monitor()->ExtensionUninstallAccepted();
    156   }
    157 
    158  private:
    159   void InitStorageMonitor() {
    160     storage_monitor_ = ExtensionStorageMonitor::Get(profile());
    161     ASSERT_TRUE(storage_monitor_);
    162 
    163     // Override thresholds so that we don't have to write a huge amount of data
    164     // to trigger notifications in these tests.
    165     storage_monitor_->enable_for_all_extensions_ = true;
    166     storage_monitor_->initial_extension_threshold_ = kInitialUsageThreshold;
    167     storage_monitor_->initial_ephemeral_threshold_ = kInitialUsageThreshold;
    168 
    169     // To ensure storage events are dispatched from QuotaManager immediately.
    170     storage_monitor_->observer_rate_ = 0;
    171   }
    172 
    173   // Write a number of bytes to persistent storage.
    174   void WriteBytes(const Extension* extension,
    175                   int num_bytes,
    176                   bool expected_notification) {
    177     ExtensionTestMessageListener launched_listener("launched", true);
    178     ExtensionTestMessageListener write_complete_listener(
    179         "write_complete", false);
    180     NotificationObserver notification_observer(
    181         GetNotificationId(extension->id()));
    182 
    183     OpenApplication(AppLaunchParams(
    184         profile(), extension, LAUNCH_CONTAINER_NONE, NEW_WINDOW));
    185     ASSERT_TRUE(launched_listener.WaitUntilSatisfied());
    186 
    187     // Instruct the app to write |num_bytes| of data.
    188     launched_listener.Reply(base::IntToString(num_bytes));
    189     ASSERT_TRUE(write_complete_listener.WaitUntilSatisfied());
    190 
    191     if (expected_notification) {
    192       EXPECT_TRUE(notification_observer.WaitForNotification());
    193     } else {
    194       base::RunLoop().RunUntilIdle();
    195       EXPECT_FALSE(notification_observer.HasReceivedNotification());
    196     }
    197   }
    198 
    199   ExtensionStorageMonitor* storage_monitor_;
    200 };
    201 
    202 // Control - No notifications should be shown if usage remains under the
    203 // threshold.
    204 IN_PROC_BROWSER_TEST_F(ExtensionStorageMonitorTest, UnderThreshold) {
    205   const Extension* extension = InitWriteDataApp();
    206   ASSERT_TRUE(extension);
    207   WriteBytesNotExpectingNotification(extension, 1);
    208 }
    209 
    210 // Ensure a notification is shown when usage reaches the first threshold.
    211 IN_PROC_BROWSER_TEST_F(ExtensionStorageMonitorTest, ExceedInitialThreshold) {
    212   const Extension* extension = InitWriteDataApp();
    213   ASSERT_TRUE(extension);
    214   WriteBytesExpectingNotification(extension, GetInitialExtensionThreshold());
    215 }
    216 
    217 // Ensure a notification is shown when usage immediately exceeds double the
    218 // first threshold.
    219 IN_PROC_BROWSER_TEST_F(ExtensionStorageMonitorTest, DoubleInitialThreshold) {
    220   const Extension* extension = InitWriteDataApp();
    221   ASSERT_TRUE(extension);
    222   WriteBytesExpectingNotification(extension,
    223                                   GetInitialExtensionThreshold() * 2);
    224 }
    225 
    226 // Ensure that notifications are not fired if the next threshold has not been
    227 // reached.
    228 IN_PROC_BROWSER_TEST_F(ExtensionStorageMonitorTest, ThrottleNotifications) {
    229   const Extension* extension = InitWriteDataApp();
    230   ASSERT_TRUE(extension);
    231 
    232   // Exceed the first threshold.
    233   WriteBytesExpectingNotification(extension, GetInitialExtensionThreshold());
    234 
    235   // Stay within the next threshold.
    236   WriteBytesNotExpectingNotification(extension, 1);
    237 }
    238 
    239 // Verify that notifications are disabled when the user clicks the action button
    240 // in the notification.
    241 IN_PROC_BROWSER_TEST_F(ExtensionStorageMonitorTest, UserDisabledNotifications) {
    242   const Extension* extension = InitWriteDataApp();
    243   ASSERT_TRUE(extension);
    244   WriteBytesExpectingNotification(extension, GetInitialExtensionThreshold());
    245 
    246   EXPECT_TRUE(IsStorageNotificationEnabled(extension->id()));
    247 
    248   // Fake clicking the notification button to disable notifications.
    249   message_center::MessageCenter::Get()->ClickOnNotificationButton(
    250       GetNotificationId(extension->id()),
    251       ExtensionStorageMonitor::BUTTON_DISABLE_NOTIFICATION);
    252 
    253   EXPECT_FALSE(IsStorageNotificationEnabled(extension->id()));
    254 
    255   // Expect to receive no further notifications when usage continues to
    256   // increase.
    257   int64 next_threshold = GetNextStorageThreshold(extension->id());
    258   int64 next_data_size = next_threshold - GetInitialExtensionThreshold();
    259   ASSERT_GT(next_data_size, 0);
    260 
    261   WriteBytesNotExpectingNotification(extension, next_data_size);
    262 }
    263 
    264 // Verify that thresholds for ephemeral apps are reset when they are
    265 // promoted to regular installed apps.
    266 IN_PROC_BROWSER_TEST_F(ExtensionStorageMonitorTest, EphemeralAppLowUsage) {
    267   const Extension* extension = InitWriteDataEphemeralApp();
    268   ASSERT_TRUE(extension);
    269   WriteBytesExpectingNotification(extension, GetInitialEphemeralThreshold());
    270 
    271   // Store the number of bytes until the next threshold is reached.
    272   int64 next_threshold = GetNextStorageThreshold(extension->id());
    273   int64 next_data_size = next_threshold - GetInitialEphemeralThreshold();
    274   ASSERT_GT(next_data_size, 0);
    275   EXPECT_GE(GetInitialExtensionThreshold(), next_threshold);
    276 
    277   // Promote the ephemeral app.
    278   ExtensionService* service =
    279       ExtensionSystem::Get(profile())->extension_service();
    280   service->PromoteEphemeralApp(extension, false);
    281 
    282   // The next threshold should now be equal to the initial threshold for
    283   // extensions (which is higher than the initial threshold for ephemeral apps).
    284   EXPECT_EQ(GetInitialExtensionThreshold(),
    285             GetNextStorageThreshold(extension->id()));
    286 
    287   // Since the threshold was increased, a notification should not be
    288   // triggered.
    289   WriteBytesNotExpectingNotification(extension, next_data_size);
    290 }
    291 
    292 // Verify that thresholds for ephemeral apps are not reset when they are
    293 // promoted to regular installed apps if their usage is higher than the initial
    294 // threshold for installed extensions.
    295 IN_PROC_BROWSER_TEST_F(ExtensionStorageMonitorTest, EphemeralAppWithHighUsage) {
    296   const Extension* extension = InitWriteDataEphemeralApp();
    297   ASSERT_TRUE(extension);
    298   WriteBytesExpectingNotification(extension, GetInitialExtensionThreshold());
    299   int64 saved_next_threshold = GetNextStorageThreshold(extension->id());
    300 
    301   // Promote the ephemeral app.
    302   ExtensionService* service =
    303       ExtensionSystem::Get(profile())->extension_service();
    304   service->PromoteEphemeralApp(extension, false);
    305 
    306   // The next threshold should not have changed.
    307   EXPECT_EQ(saved_next_threshold, GetNextStorageThreshold(extension->id()));
    308 }
    309 
    310 // Ensure that monitoring is disabled for installed extensions if
    311 // |enable_for_all_extensions_| is false. This test can be removed if monitoring
    312 // is eventually enabled for all extensions.
    313 IN_PROC_BROWSER_TEST_F(ExtensionStorageMonitorTest,
    314                        DisableForInstalledExtensions) {
    315   DisableForInstalledExtensions();
    316 
    317   const Extension* extension = InitWriteDataApp();
    318   ASSERT_TRUE(extension);
    319   WriteBytesNotExpectingNotification(extension, GetInitialExtensionThreshold());
    320 }
    321 
    322 // Verify that notifications are disabled when the user clicks the action button
    323 // in the notification.
    324 IN_PROC_BROWSER_TEST_F(ExtensionStorageMonitorTest, UninstallExtension) {
    325   const Extension* extension = InitWriteDataApp();
    326   ASSERT_TRUE(extension);
    327   WriteBytesExpectingNotification(extension, GetInitialExtensionThreshold());
    328 
    329   // Fake clicking the notification button to uninstall.
    330   message_center::MessageCenter::Get()->ClickOnNotificationButton(
    331       GetNotificationId(extension->id()),
    332       ExtensionStorageMonitor::BUTTON_UNINSTALL);
    333 
    334   // Also fake accepting the uninstall.
    335   content::WindowedNotificationObserver uninstalled_signal(
    336       chrome::NOTIFICATION_EXTENSION_UNINSTALLED_DEPRECATED,
    337       content::Source<Profile>(profile()));
    338   SimulateUninstallDialogAccept();
    339   uninstalled_signal.Wait();
    340 }
    341 
    342 }  // namespace extensions
    343