[SystemInfo API] Implement systemInfo.storage.onAvailableCapacityChanged event

chrome/browser/extensions/system_info_event_router.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/system_info_event_router.h"
 
 #include "base/bind.h"
 #include "base/memory/scoped_ptr.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/extensions/event_router_forwarder.h"
@@ skipping 32 matching lines @@
   return Singleton<SystemInfoEventRouter>::get();
 }
 
 SystemInfoEventRouter::SystemInfoEventRouter() {
 }
 
 SystemInfoEventRouter::~SystemInfoEventRouter() {
 }
 
 void SystemInfoEventRouter::AddEventListener(const std::string& event_name) {
   watching_event_set_.insert(event_name);

[benwells, 2013/01/31 04:04:57]

Nit: add DCHECK that are on the UI thread.

[Hongbo Min, 2013/02/01 07:06:50]

Done for both AddEventListener and RemoveEventListener.

   if (watching_event_set_.count(event_name) > 1)
     return;
   // Start watching the |event_name| event if the first event listener arrives.
   // For systemInfo.storage event.
   if (IsStorageEvent(event_name)) {
-    // TODO (hongbo): Start watching storage device information via calling
-    // SystemMonitor::StartWatchingStorage.
+    StorageInfoProvider::Get()->AddObserver(this);
+    StorageInfo info;
+    if (StorageInfoProvider::Get()->QueryInfo(&info)) {
+      for (StorageInfo::iterator it = info.begin(); it != info.end(); ++it)
+        StorageInfoProvider::Get()->StartWatching((*it)->id);
+    }
     return;
   }
 
   // For systemInfo.cpu event.
   if (IsCpuEvent(event_name)) {
     CpuInfoProvider::Get()->StartSampling(
         base::Bind(&SystemInfoEventRouter::OnNextCpuSampling,
                    base::Unretained(this)));
     return;
   }
 }
 
 void SystemInfoEventRouter::RemoveEventListener(
     const std::string& event_name) {
   watching_event_set_.erase(event_name);
   if (watching_event_set_.count(event_name) > 0)
     return;
 
   // In case of the last event listener is removed, we need to stop watching
   // it to avoid unnecessary overhead.
   if (IsStorageEvent(event_name)) {
-    // TODO(hongbo): Stop watching storage device information via calling
-    // SystemMonitor::StopWatchingStorage.
+    StorageInfo info;
+    if (StorageInfoProvider::Get()->QueryInfo(&info)) {
+      for (StorageInfo::iterator it = info.begin(); it != info.end(); ++it)
+        StorageInfoProvider::Get()->StopWatching((*it)->id);
+    }
+    StorageInfoProvider::Get()->RemoveObserver(this);
     return;
   }
   if (IsCpuEvent(event_name)) {
     CpuInfoProvider::Get()->StopSampling();
   }
 }
 
 // static
 bool SystemInfoEventRouter::IsSystemInfoEvent(const std::string& event_name) {
   std::string prefix(kSystemInfoEventPrefix);
   return event_name.compare(0, prefix.size(), prefix) == 0;
 }
 
-void SystemInfoEventRouter::OnStorageAvailableCapacityChanged(
-    const std::string& id, int64 available_capacity) {
-  if (!BrowserThread::CurrentlyOn(BrowserThread::UI)) {
-    BrowserThread::PostTask(BrowserThread::UI, FROM_HERE,
-        base::Bind(&SystemInfoEventRouter::OnStorageAvailableCapacityChanged,
-                   base::Unretained(this), id, available_capacity));
-    return;
-  }
-
-  // We are on the UI thread now.
+// Called on UI thread since the observer is added from UI thread.
+void SystemInfoEventRouter::OnStorageFreeSpaceChanged(
+    const std::string& id, double new_value, double old_value) {

[benwells, 2013/01/31 04:04:57]

I don't understand why the threading stuff changed here. Isn't this still called
from the blocking pool?

[Hongbo Min, 2013/02/01 07:06:50]

Since the observers of StorageInfoProvider are hold in a ObserverListThreadSafe
list, which means that the observer needs to only care about on which thread it
is added, so no need to check the thread type to ensure it running on UI thread.

[benwells, 2013/02/04 04:21:41]

Oh wow, I didn't realize that class was so smart. Neat!

   StorageChangeInfo info;
   info.id = id;
-  info.available_capacity = static_cast<double>(available_capacity);
+  info.available_capacity = static_cast<double>(new_value);
 
   scoped_ptr<base::ListValue> args(new base::ListValue());
   args->Append(info.ToValue().release());
 
   DispatchEvent(event_names::kOnStorageAvailableCapacityChanged, args.Pass());
 }
 
 void SystemInfoEventRouter::OnRemovableStorageAttached(const std::string& id,
     const string16& name,  const FilePath::StringType& location) {
   // TODO(hongbo): Handle storage device arrival/removal event.
@@ skipping 10 matching lines @@
 }
 
 void SystemInfoEventRouter::OnNextCpuSampling(scoped_ptr<CpuUpdateInfo> info) {
   scoped_ptr<base::ListValue> args(new base::ListValue());
   args->Append(info->ToValue().release());
 
   DispatchEvent(event_names::kOnCpuUpdated, args.Pass());
 }
 
 }  // namespace extensions