Change webkit/{fileapi,quota} code to use TaskRunner.

webkit/quota/quota_manager.h

 // 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.
 
 #ifndef WEBKIT_QUOTA_QUOTA_MANAGER_H_
 #define WEBKIT_QUOTA_QUOTA_MANAGER_H_
 #pragma once
 
 #include <deque>
 #include <list>
 #include <map>
 #include <set>
 #include <string>
 #include <utility>
 #include <vector>
 
 #include "base/basictypes.h"
 #include "base/callback.h"
 #include "base/file_path.h"
 #include "base/memory/ref_counted.h"
+#include "base/memory/scoped_ptr.h"
 #include "base/memory/weak_ptr.h"
-#include "base/memory/scoped_ptr.h"
 #include "base/memory/weak_ptr.h"
 #include "webkit/quota/quota_database.h"
 #include "webkit/quota/quota_client.h"
 #include "webkit/quota/quota_task.h"
 #include "webkit/quota/quota_types.h"
 #include "webkit/quota/special_storage_policy.h"
 
 class FilePath;
 
 namespace base {
-class MessageLoopProxy;
+class SequencedTaskRunner;
+class SingleThreadTaskRunner;
 }
 
 namespace quota_internals {
 class QuotaInternalsProxy;
 }
 
 namespace quota {
 
 struct QuotaManagerDeleter;
 
@@ skipping 54 matching lines @@
                      public base::RefCountedThreadSafe<
                          QuotaManager, QuotaManagerDeleter> {
  public:
   typedef base::Callback<void(QuotaStatusCode,
                               int64 /* usage */,
                               int64 /* quota */)>
       GetUsageAndQuotaCallback;
 
   QuotaManager(bool is_incognito,
                const FilePath& profile_path,
-               base::MessageLoopProxy* io_thread,
-               base::MessageLoopProxy* db_thread,
+               base::SingleThreadTaskRunner* io_thread,
+               base::SequencedTaskRunner* db_thread,

[michaeln, 2012/04/27 01:04:03]

Yup... SingleThread for the first, Sequenced for the second looks spot on here.

                SpecialStoragePolicy* special_storage_policy);
 
   virtual ~QuotaManager();
 
   // Returns a proxy object that can be used on any thread.
   QuotaManagerProxy* proxy() { return proxy_.get(); }
 
   // Called by clients or webapps. Returns usage per host.
   void GetUsageInfo(const GetUsageInfoCallback& callback);
 
@@ skipping 222 matching lines @@
   void DidGetDatabaseLRUOrigin(const GURL& origin);
 
   void DeleteOnCorrectThread() const;
 
   const bool is_incognito_;
   const FilePath profile_path_;
 
   scoped_refptr<QuotaManagerProxy> proxy_;
   bool db_disabled_;
   bool eviction_disabled_;
-  scoped_refptr<base::MessageLoopProxy> io_thread_;
-  scoped_refptr<base::MessageLoopProxy> db_thread_;
+  scoped_refptr<base::SingleThreadTaskRunner> io_thread_;
+  scoped_refptr<base::SequencedTaskRunner> db_thread_;
   mutable scoped_ptr<QuotaDatabase> database_;
 
   GetLRUOriginCallback lru_origin_callback_;
   std::set<GURL> access_notified_origins_;
 
   QuotaClientList clients_;
 
   scoped_ptr<UsageTracker> temporary_usage_tracker_;
   scoped_ptr<UsageTracker> persistent_usage_tracker_;
   // TODO(michaeln): Need a way to clear the cache, drop and
@@ skipping 44 matching lines @@
   virtual void NotifyOriginNoLongerInUse(const GURL& origin);
 
   // This method may only be called on the IO thread.
   // It may return NULL if the manager has already been deleted.
   QuotaManager* quota_manager() const;
 
  protected:
   friend class QuotaManager;
   friend class base::RefCountedThreadSafe<QuotaManagerProxy>;
 
-  QuotaManagerProxy(QuotaManager* manager, base::MessageLoopProxy* io_thread);
+  QuotaManagerProxy(QuotaManager* manager,
+                    base::SingleThreadTaskRunner* io_thread);
   virtual ~QuotaManagerProxy();
 
   QuotaManager* manager_;  // only accessed on the io thread
-  scoped_refptr<base::MessageLoopProxy> io_thread_;
+  scoped_refptr<base::SingleThreadTaskRunner> io_thread_;
 
   DISALLOW_COPY_AND_ASSIGN(QuotaManagerProxy);
 };
 
 }  // namespace quota
 
 #endif  // WEBKIT_QUOTA_QUOTA_MANAGER_H_