Extend the capability of SystemMonitor to support watching storage free space change

base/system_monitor/system_monitor_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 "base/system_monitor/system_monitor.h"
 
 #include "base/file_path.h"
 #include "base/message_loop.h"
 #include "base/test/mock_devices_changed_observer.h"
 #include "base/utf_string_conversions.h"
@@ skipping 29 matching lines @@
   int power_state_changes() { return power_state_changes_; }
   int suspends() { return suspends_; }
   int resumes() { return resumes_; }
 
  private:
   int power_state_changes_;  // Count of OnPowerStateChange notifications.
   int suspends_;  // Count of OnSuspend notifications.
   int resumes_;  // Count of OnResume notifications.
 };
 
+class MockStorageFreeSpaceDelegateTest
+    : public SystemMonitor::StorageFreeSpaceDelegate {
+ public:
+  MockStorageFreeSpaceDelegateTest() {}
+  virtual ~MockStorageFreeSpaceDelegateTest() {}
+  MOCK_METHOD1(StartWatchingStorage, void(const FilePath& path));
+  MOCK_METHOD1(StopWatchingStorage, void(const FilePath& path));
+  DISALLOW_COPY_AND_ASSIGN(MockStorageFreeSpaceDelegateTest);
+};
+
+class MockStorageFreeSpaceObserver
+    : public SystemMonitor::StorageFreeSpaceObserver {
+ public:
+  MockStorageFreeSpaceObserver() {}
+  virtual ~MockStorageFreeSpaceObserver() {}
+  MOCK_METHOD2(OnFreeSpaceChanged,
+               void(const FilePath& path, int64 available_bytes));
+  MOCK_METHOD1(OnFreeSpaceChangeError,
+               void(const FilePath& path));
+  DISALLOW_COPY_AND_ASSIGN(MockStorageFreeSpaceObserver);
+};
+
 class SystemMonitorTest : public testing::Test {
  protected:
   SystemMonitorTest() {
 #if defined(OS_MACOSX)
     // This needs to happen before SystemMonitor's ctor.
     SystemMonitor::AllocateSystemIOPorts();
 #endif
-    system_monitor_.reset(new SystemMonitor);
+    system_monitor_.reset(new SystemMonitor(&delegate_test_));
   }
   virtual ~SystemMonitorTest() {}
 
   MessageLoop message_loop_;
   scoped_ptr<SystemMonitor> system_monitor_;
+  MockStorageFreeSpaceDelegateTest delegate_test_;
 
   DISALLOW_COPY_AND_ASSIGN(SystemMonitorTest);
 };
 
 TEST_F(SystemMonitorTest, PowerNotifications) {
   const int kObservers = 5;
 
   PowerTest test[kObservers];
   for (int index = 0; index < kObservers; ++index)
     system_monitor_->AddPowerObserver(&test[index]);
@@ skipping 117 matching lines @@
   EXPECT_EQ(kDeviceId2, devices[0].device_id);
   EXPECT_EQ(kDeviceName2, devices[0].name);
   EXPECT_EQ(kDevicePath2.value(), devices[0].location);
 
   system_monitor_->ProcessRemovableStorageDetached(kDeviceId2);
   message_loop_.RunAllPending();
   devices = system_monitor_->GetAttachedRemovableStorage();
   EXPECT_EQ(0U, devices.size());
 }
 
+TEST_F(SystemMonitorTest, StorageFreeSpaceChangedNotification) {
+  const int kObservers = 3;
+  const FilePath kFilePath(FILE_PATH_LITERAL("one"));
+  const FilePath kInvalidFilePath(FILE_PATH_LITERAL("invalid_path"));
+
+  testing::Sequence mock_sequencer[kObservers], seq;
+  MockStorageFreeSpaceObserver observers[kObservers];
+
+  EXPECT_CALL(delegate_test_,
+              StartWatchingStorage(kFilePath))
+      .Times(1).InSequence(seq);
+  EXPECT_CALL(delegate_test_,
+              StartWatchingStorage(kInvalidFilePath))
+      .Times(1).InSequence(seq);
+  EXPECT_CALL(delegate_test_,
+              StopWatchingStorage(kFilePath))
+      .Times(1).InSequence(seq);
+  EXPECT_CALL(delegate_test_,
+              StopWatchingStorage(kInvalidFilePath))
+      .Times(0).InSequence(seq);
+
+  for (int i = 0; i < kObservers - 1; ++i) {
+    EXPECT_CALL(observers[i],
+                OnFreeSpaceChanged(kFilePath, 1000))
+        .Times(1).InSequence(mock_sequencer[i]);
+    EXPECT_CALL(observers[i],
+                OnFreeSpaceChanged(kFilePath, 2000))
+        .Times(1).InSequence(mock_sequencer[i]);
+    EXPECT_CALL(observers[i],
+              OnFreeSpaceChangeError(kFilePath))
+        .Times(0).InSequence(mock_sequencer[i]);
+  }
+  EXPECT_CALL(observers[kObservers - 1],
+              OnFreeSpaceChangeError(kInvalidFilePath))
+        .Times(1).InSequence(mock_sequencer[kObservers - 1]);
+  EXPECT_CALL(observers[0],
+              OnFreeSpaceChanged(kFilePath, 3000))
+        .Times(1).InSequence(mock_sequencer[kObservers - 1]);
+  EXPECT_CALL(observers[1],
+              OnFreeSpaceChanged(kFilePath, 3000))
+        .Times(0).InSequence(mock_sequencer[kObservers - 1]);
+
+  system_monitor_->AddStorageFreeSpaceObserver(kFilePath, &observers[0]);
+  system_monitor_->AddStorageFreeSpaceObserver(kFilePath, &observers[1]);
+
+  system_monitor_->ProcessStorageFreeSpaceChanged(kFilePath, 1000);
+  system_monitor_->ProcessStorageFreeSpaceChanged(kFilePath, 2000);
+  message_loop_.RunAllPending();
+
+  system_monitor_->AddStorageFreeSpaceObserver(kInvalidFilePath, &observers[2]);
+  system_monitor_->ProcessStorageFreeSpaceChangeError(kInvalidFilePath);
+  message_loop_.RunAllPending();
+
+  system_monitor_->RemoveStorageFreeSpaceObserver(kFilePath, &observers[1]);
+  system_monitor_->ProcessStorageFreeSpaceChanged(kFilePath, 3000);
+  message_loop_.RunAllPending();
+
+  system_monitor_->RemoveStorageFreeSpaceObserver(kFilePath, &observers[0]);
+  message_loop_.RunAllPending();
+}
+
 }  // namespace
 
 }  // namespace base