Move IndexedDB from WEBKIT_DEPRECATED to dedicated thread

chrome/browser/browsing_data/browsing_data_indexed_db_helper.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/browsing_data/browsing_data_indexed_db_helper.h"
 
 #include <vector>
 
 #include "base/bind.h"
 #include "base/callback.h"
 #include "base/compiler_specific.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/message_loop.h"
 #include "base/strings/string_util.h"
 #include "base/strings/utf_string_conversions.h"
 #include "chrome/browser/browsing_data/browsing_data_helper.h"
+#include "chrome/browser/profiles/profile.h"
+#include "content/public/browser/browser_context.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/indexed_db_context.h"
-#include "webkit/browser/database/database_util.h"
+#include "content/public/browser/storage_partition.h"
 
+using content::BrowserContext;
 using content::BrowserThread;
 using content::IndexedDBContext;
 using content::IndexedDBInfo;
-using webkit_database::DatabaseUtil;
 
 namespace {
 
 class BrowsingDataIndexedDBHelperImpl : public BrowsingDataIndexedDBHelper {
  public:
   explicit BrowsingDataIndexedDBHelperImpl(
       IndexedDBContext* indexed_db_context);
 
   virtual void StartFetching(
       const base::Callback<void(const std::list<IndexedDBInfo>&)>&
           callback) OVERRIDE;
   virtual void DeleteIndexedDB(const GURL& origin) OVERRIDE;
 
  private:
   virtual ~BrowsingDataIndexedDBHelperImpl();
 
-  // Enumerates all indexed database files in the WEBKIT thread.
-  void FetchIndexedDBInfoInWebKitThread();
+  // Enumerates all indexed database files in the IndexedDB thread.
+  void FetchIndexedDBInfoInIndexedDBThread();
   // Notifies the completion callback in the UI thread.
   void NotifyInUIThread();
-  // Delete a single indexed database in the WEBKIT thread.
-  void DeleteIndexedDBInWebKitThread(const GURL& origin);
+  // Delete a single indexed database in the IndexedDB thread.
+  void DeleteIndexedDBInIndexedDBThread(const GURL& origin);
 
   scoped_refptr<IndexedDBContext> indexed_db_context_;
 
   // Access to |indexed_db_info_| is triggered indirectly via the UI thread and
   // guarded by |is_fetching_|. This means |indexed_db_info_| is only accessed
   // while |is_fetching_| is true. The flag |is_fetching_| is only accessed on
   // the UI thread.
   // In the context of this class |indexed_db_info_| is only accessed on the
-  // WEBKIT thread.
+  // context's IndexedDB thread.
   std::list<IndexedDBInfo> indexed_db_info_;
 
   // This only mutates on the UI thread.
   base::Callback<void(const std::list<IndexedDBInfo>&)> completion_callback_;
 
   // Indicates whether or not we're currently fetching information:
   // it's true when StartFetching() is called in the UI thread, and it's reset
   // after we notified the callback in the UI thread.
   // This only mutates on the UI thread.
   bool is_fetching_;
@@ skipping 12 matching lines @@
 }
 
 void BrowsingDataIndexedDBHelperImpl::StartFetching(
     const base::Callback<void(const std::list<IndexedDBInfo>&)>& callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK(!is_fetching_);
   DCHECK_EQ(false, callback.is_null());
 
   is_fetching_ = true;
   completion_callback_ = callback;
-  BrowserThread::PostTask(
-      BrowserThread::WEBKIT_DEPRECATED, FROM_HERE,
+  indexed_db_context_->TaskRunner()->PostTask(
+      FROM_HERE,
       base::Bind(
-          &BrowsingDataIndexedDBHelperImpl::FetchIndexedDBInfoInWebKitThread,
+          &BrowsingDataIndexedDBHelperImpl::FetchIndexedDBInfoInIndexedDBThread,
           this));
 }
 
 void BrowsingDataIndexedDBHelperImpl::DeleteIndexedDB(
     const GURL& origin) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
-  BrowserThread::PostTask(
-      BrowserThread::WEBKIT_DEPRECATED, FROM_HERE,
+  indexed_db_context_->TaskRunner()->PostTask(
+      FROM_HERE,
       base::Bind(
-          &BrowsingDataIndexedDBHelperImpl::DeleteIndexedDBInWebKitThread, this,
+          &BrowsingDataIndexedDBHelperImpl::DeleteIndexedDBInIndexedDBThread,
+          this,
           origin));
 }
 
-void BrowsingDataIndexedDBHelperImpl::FetchIndexedDBInfoInWebKitThread() {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::WEBKIT_DEPRECATED));
+void BrowsingDataIndexedDBHelperImpl::FetchIndexedDBInfoInIndexedDBThread() {
+  DCHECK(indexed_db_context_->OnIndexedDBThread());
   std::vector<IndexedDBInfo> origins = indexed_db_context_->GetAllOriginsInfo();
   for (std::vector<IndexedDBInfo>::const_iterator iter = origins.begin();
        iter != origins.end(); ++iter) {
     const IndexedDBInfo& origin = *iter;
     if (!BrowsingDataHelper::HasWebScheme(origin.origin_))
       continue;  // Non-websafe state is not considered browsing data.
 
     indexed_db_info_.push_back(origin);
   }
 
   BrowserThread::PostTask(
       BrowserThread::UI, FROM_HERE,
       base::Bind(&BrowsingDataIndexedDBHelperImpl::NotifyInUIThread, this));
 }
 
 void BrowsingDataIndexedDBHelperImpl::NotifyInUIThread() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK(is_fetching_);
   completion_callback_.Run(indexed_db_info_);
   completion_callback_.Reset();
   is_fetching_ = false;
 }
 
-void BrowsingDataIndexedDBHelperImpl::DeleteIndexedDBInWebKitThread(
+void BrowsingDataIndexedDBHelperImpl::DeleteIndexedDBInIndexedDBThread(
     const GURL& origin) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::WEBKIT_DEPRECATED));
+  DCHECK(indexed_db_context_->OnIndexedDBThread());
   indexed_db_context_->DeleteForOrigin(origin);
 }
 
 }  // namespace
 
 
 // static
 BrowsingDataIndexedDBHelper* BrowsingDataIndexedDBHelper::Create(
     IndexedDBContext* indexed_db_context) {
   return new BrowsingDataIndexedDBHelperImpl(indexed_db_context);
@@ skipping 10 matching lines @@
 PendingIndexedDBInfo::~PendingIndexedDBInfo() {
 }
 
 bool CannedBrowsingDataIndexedDBHelper::PendingIndexedDBInfo::operator<(
     const PendingIndexedDBInfo& other) const {
   if (origin == other.origin)
     return name < other.name;
   return origin < other.origin;
 }
 
-CannedBrowsingDataIndexedDBHelper::CannedBrowsingDataIndexedDBHelper()
-    : is_fetching_(false) {
-}
+CannedBrowsingDataIndexedDBHelper::CannedBrowsingDataIndexedDBHelper(
+    Profile* profile)
+    : profile_(profile),
+      indexed_db_context_(BrowserContext::GetDefaultStoragePartition(profile)
+                          ->GetIndexedDBContext()),
+      is_fetching_(false) {}
 
 CannedBrowsingDataIndexedDBHelper::~CannedBrowsingDataIndexedDBHelper() {}
 
 CannedBrowsingDataIndexedDBHelper* CannedBrowsingDataIndexedDBHelper::Clone() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   CannedBrowsingDataIndexedDBHelper* clone =
-      new CannedBrowsingDataIndexedDBHelper();
+      new CannedBrowsingDataIndexedDBHelper(profile_);
 
   base::AutoLock auto_lock(lock_);
   clone->pending_indexed_db_info_ = pending_indexed_db_info_;
   clone->indexed_db_info_ = indexed_db_info_;
   return clone;
 }
 
 void CannedBrowsingDataIndexedDBHelper::AddIndexedDB(
     const GURL& origin, const string16& name) {
   if (!BrowsingDataHelper::HasWebScheme(origin))
@@ skipping 26 matching lines @@
 }
 
 void CannedBrowsingDataIndexedDBHelper::StartFetching(
     const base::Callback<void(const std::list<IndexedDBInfo>&)>& callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK(!is_fetching_);
   DCHECK_EQ(false, callback.is_null());
 
   is_fetching_ = true;
   completion_callback_ = callback;
-  BrowserThread::PostTask(
-      BrowserThread::WEBKIT_DEPRECATED, FROM_HERE,
-      base::Bind(
-          &CannedBrowsingDataIndexedDBHelper::ConvertPendingInfoInWebKitThread,
-          this));
+  indexed_db_context_->TaskRunner()->PostTask(
+      FROM_HERE,
+      base::Bind(&CannedBrowsingDataIndexedDBHelper::
+                     ConvertPendingInfoInIndexedDBThread,
+                 this));
 }
 
-void CannedBrowsingDataIndexedDBHelper::ConvertPendingInfoInWebKitThread() {
+void CannedBrowsingDataIndexedDBHelper::ConvertPendingInfoInIndexedDBThread() {
   base::AutoLock auto_lock(lock_);
   indexed_db_info_.clear();
   for (std::set<PendingIndexedDBInfo>::const_iterator
        pending_info = pending_indexed_db_info_.begin();
        pending_info != pending_indexed_db_info_.end(); ++pending_info) {
     IndexedDBInfo info(pending_info->origin, 0, base::Time(), base::FilePath());

[michaeln, 2013/06/21 19:35:57]

Not sure there's a need for a dependency on a Profile or real idbcontext in this
canned mock class.

There is nothing about this loop that requires it to be run on some special
background thread (afaict). The setup required to make it such that you can run
this loop on the special background thread might be be more trouble than it is
worth.

I think StartFetching could populate the indexed_db_info_ collection and then
MessageLoop::current()->PostTask(&NotifyInUIThread) to deliver the callback
asyncly.

[jsbell, 2013/06/21 20:39:37]

Yeah, I remember your feedback from the previous CL. I'll take another look - I
was looking at adjacent files for the pattern to follow, but it can probably be
simplified.

[jsbell, 2013/06/24 17:50:43]

Digging through history, it looks like this plumbing was put in in
crrev.com/6246105 due to unsafe access to WebSecurityOrigin from the UI thread.
The guts of the IndexedDBInfo copying therefore was moved to the WEBKIT thread.
Since then, IndexedDBInfo has dropped dependency on WebSecurityOrigin so this
can be dramatically simplified.

I'll post a separate CL which does that and land it first.

     indexed_db_info_.push_back(info);
   }
 
   BrowserThread::PostTask(
       BrowserThread::UI, FROM_HERE,
       base::Bind(&CannedBrowsingDataIndexedDBHelper::NotifyInUIThread, this));
 }
 
 void CannedBrowsingDataIndexedDBHelper::NotifyInUIThread() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK(is_fetching_);
 
   completion_callback_.Run(indexed_db_info_);
   completion_callback_.Reset();
   is_fetching_ = false;
 }