[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 22 matching lines @@
 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;
 
-  SystemInfoProvider()
-    : is_waiting_for_completion_(false) {
+  SystemInfoProvider() : is_waiting_for_completion_(false) {

[Lei Zhang, 2013/05/28 08:08:07]

(Slightly off-topic) Why are all the implementations in the .h file?

[Hongbo Min, 2013/05/28 14:24:01]

Because the SystemInfoProvider class is just a template class. We might extract
some code into .cc file by introducing a new class like SystemInfoProviderBase.

[Lei Zhang, 2013/05/28 21:16:44]

It doesn't have to be in the .h file. Maybe after this CL, I can help you move
things into a .cc file.

     worker_pool_token_ =
-      content::BrowserThread::GetBlockingPool()->GetSequenceToken();
+        content::BrowserThread::GetBlockingPool()->GetSequenceToken();
   }
 
   virtual ~SystemInfoProvider() {}
 
   // For testing
   static void InitializeForTesting(
       scoped_refptr<SystemInfoProvider<T> > provider) {
     DCHECK(provider != NULL);
     single_shared_provider_.Get() = provider;
   }
 
   // Start to query the system information. Should be called on UI thread.
   // The |callback| will get called once the query is completed.
   void StartQueryInfo(const QueryInfoCompletionCallback& callback) {
     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.
+  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.
+  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.
   virtual bool QueryInfo(T* info) = 0;
 
   virtual void QueryOnWorkerPool() {
     bool success = QueryInfo(&info_);
     content::BrowserThread::PostTask(content::BrowserThread::UI, FROM_HERE,
         base::Bind(&SystemInfoProvider<T>::OnQueryCompleted, this, success));
@@ skipping 47 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_