[SystemInfo API] Rewrite storage info provider using storage monitor impl.

chrome/browser/extensions/api/system_info/system_info_provider.h

 // Copyright 2013 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.
 #ifndef CHROME_BROWSER_EXTENSIONS_API_SYSTEM_INFO_SYSTEM_INFO_PROVIDER_H_
 #define CHROME_BROWSER_EXTENSIONS_API_SYSTEM_INFO_SYSTEM_INFO_PROVIDER_H_
 
 #include <queue>
 
 #include "base/bind.h"
 #include "base/callback.h"
@@ skipping 11 matching lines @@
 // The SystemInfoProvider is designed to query system information on the worker
 // pool. It also maintains a queue of callbacks on the UI thread which are
 // waiting for the completion of querying operation. Once the query operation
 // is completed, all pending callbacks in the queue get called on the UI
 // thread. In this way, it avoids frequent querying operation in case of lots
 // of query requests, e.g. calling systemInfo.cpu.get repeatedly in an
 // extension process.
 //
 // Template parameter T is the system information type. It could be the
 // structure type generated by IDL parser.
+//
+// The class member info_ is accessed on multiple threads, but that the whole
+// class is being guarded by SystemInfoProvider.
+//
+// SystemInfoProvider maintains a variable |is_waiting_for_completion_| on UI

[Jeffrey Yasskin, 2013/07/03 21:44:49]

To summarize this long paragraph, would it be correct to just say "info_ is
accessed on the UI thread while |is_waiting_for_completion_| is false and on the
BlockingPool under worker_pool_token_ while |is_waiting_for_completion_| is
true."? If that's correct, just replace the previous paragraph with it and
remove this one.

[Haojian Wu, 2013/07/04 00:41:17]

I think so. Done.

+// thread. The |is_waiting_for_completion_| is used to ensure that only one
+// thread is accessing the |info_| member at the same time.
+// In case of |is_waiting_for_completion_| is true, the callback will be queued
+// and so no entry will be access |info_| until SystemInfoProvider::
+// OnQueryCompleted is called on UI thread.
 template<class T>
 class SystemInfoProvider
     : public base::RefCountedThreadSafe<SystemInfoProvider<T> > {
  public:
   // Callback type for completing to get information. The callback accepts
   // two arguments. The first one is the information got already, the second
   // one indicates whether its contents are valid, for example, no error
   // occurs in querying the information.
   typedef base::Callback<void(const T&, bool)> QueryInfoCompletionCallback;
   typedef std::queue<QueryInfoCompletionCallback> CallbackQueue;
@@ skipping 19 matching lines @@
     DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI));
     DCHECK(!callback.is_null());
 
     callbacks_.push(callback);
 
     if (is_waiting_for_completion_)
       return;
 
     is_waiting_for_completion_ = true;
 
+    StartQueryInfoImpl();
+  }
+
+ protected:
+  // Default implementation of querying system information.
+  //
+  // Before overriding this function, you should know what you intend to do

[Jeffrey Yasskin, 2013/07/03 21:44:49]

This sentence doesn't convey any information, so please remove it.

[Haojian Wu, 2013/07/04 00:41:17]

Done.

+  // exactly.
+  // While overriding, there are two things need to do:
+  //   1). Bind custom callback function for query system information.
+  //   2). Post the custom task to blocking pool.
+  virtual void StartQueryInfoImpl() {
+    base::Closure callback =
+        base::Bind(&SystemInfoProvider<T>::QueryOnWorkerPool, this);
+    PostQueryTaskToBlockingPool(FROM_HERE, callback);
+  }
+
+  // Post a task to blocking pool for information querying.
+  //
+  // The parameter query_callback should invoke QueryInfo directly or indirectly
+  // to query the system information and return to UI thread when the query is
+  // completed.
+  void PostQueryTaskToBlockingPool(const tracked_objects::Location& from_here,
+                                   const base::Closure& query_callback) {
+    DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI));
     base::SequencedWorkerPool* worker_pool =
         content::BrowserThread::GetBlockingPool();
     // The query task posted to the worker pool won't block shutdown, and any
     // running query task at shutdown time will be ignored.
     worker_pool->PostSequencedWorkerTaskWithShutdownBehavior(
-          worker_pool_token_,
-          FROM_HERE,
-          base::Bind(&SystemInfoProvider<T>::QueryOnWorkerPool, this),
+          worker_pool_token_, from_here, query_callback,
           base::SequencedWorkerPool::CONTINUE_ON_SHUTDOWN);
   }
 
- protected:
   // Query the system information synchronously and output the result to the
   // |info| parameter. The |info| contents MUST be reset firstly in its
   // platform specific implementation. Return true if it succeeds, otherwise
   // false is returned.
+  // TODO(Haojian): Remove the parameter T-typed pointer, replacing with void
+  // QueryInfo().
   virtual bool QueryInfo(T* info) = 0;
 
-  virtual void QueryOnWorkerPool() {
+  // TODO(Haojian): Use PostBlockingPoolTaskAndReply to avoid unnecessary
+  // trampolines trip.
+  void QueryOnWorkerPool() {
     bool success = QueryInfo(&info_);
     content::BrowserThread::PostTask(content::BrowserThread::UI, FROM_HERE,
         base::Bind(&SystemInfoProvider<T>::OnQueryCompleted, this, success));
   }
 
   // Called on UI thread. The |success| parameter means whether it succeeds
   // to get the information.
   virtual void OnQueryCompleted(bool success) {
     DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI));
 
@@ skipping 40 matching lines @@
 };
 
 // Static member intialization.
 template<class T>
 typename base::LazyInstance<scoped_refptr<SystemInfoProvider<T> > >
   SystemInfoProvider<T>::single_shared_provider_ = LAZY_INSTANCE_INITIALIZER;
 
 }  // namespace extensions
 
 #endif  // CHROME_BROWSER_EXTENSIONS_API_SYSTEM_INFO_SYSTEM_INFO_PROVIDER_H_