Port BrowsingDataDatabaseHelper to webkit_database::DatabaseIdentifier

chrome/browser/browsing_data/browsing_data_database_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_database_helper.h"
 
 #include "base/bind.h"
 #include "base/callback.h"
 #include "base/file_util.h"
 #include "base/message_loop.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_thread.h"
 #include "content/public/browser/storage_partition.h"
 #include "net/base/completion_callback.h"
 #include "net/base/net_errors.h"
 #include "third_party/WebKit/public/platform/WebCString.h"
 #include "third_party/WebKit/public/platform/WebString.h"
-#include "third_party/WebKit/public/web/WebSecurityOrigin.h"
+#include "webkit/common/database/database_identifier.h"
 
 using content::BrowserContext;
 using content::BrowserThread;
-using WebKit::WebSecurityOrigin;
+using webkit_database::DatabaseIdentifier;
 
 BrowsingDataDatabaseHelper::DatabaseInfo::DatabaseInfo(
-    const std::string& host,
+    const DatabaseIdentifier& identifier,
     const std::string& database_name,
-    const std::string& origin_identifier,
     const std::string& description,
-    const std::string& origin,
     int64 size,
     base::Time last_modified)
-    : host(host),
+    : identifier(identifier),
       database_name(database_name),
-      origin_identifier(origin_identifier),
       description(description),
-      origin(origin),
       size(size),
       last_modified(last_modified) {
 }
 
 BrowsingDataDatabaseHelper::DatabaseInfo::~DatabaseInfo() {}
 
 BrowsingDataDatabaseHelper::BrowsingDataDatabaseHelper(Profile* profile)
     : is_fetching_(false),
       tracker_(BrowserContext::
                   GetDefaultStoragePartition(profile)->GetDatabaseTracker()) {
@@ skipping 25 matching lines @@
       base::Bind(&BrowsingDataDatabaseHelper::DeleteDatabaseOnFileThread, this,
                  origin, name));
 }
 
 void BrowsingDataDatabaseHelper::FetchDatabaseInfoOnFileThread() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::FILE));
   std::vector<webkit_database::OriginInfo> origins_info;
   if (tracker_.get() && tracker_->GetAllOriginsInfo(&origins_info)) {
     for (std::vector<webkit_database::OriginInfo>::const_iterator ori =
          origins_info.begin(); ori != origins_info.end(); ++ori) {
-      WebSecurityOrigin web_security_origin =
-          WebSecurityOrigin::createFromDatabaseIdentifier(
-              WebKit::WebString::fromUTF8(ori->GetOriginIdentifier()));
-      GURL origin_url(web_security_origin.toString().utf8());
-      if (!BrowsingDataHelper::HasWebScheme(origin_url)) {
+      DatabaseIdentifier identifier =
+          DatabaseIdentifier::Parse(ori->GetOriginIdentifier());
+      if (!BrowsingDataHelper::HasWebScheme(identifier.ToOrigin())) {
         // Non-websafe state is not considered browsing data.
         continue;
       }
       std::vector<string16> databases;
       ori->GetAllDatabaseNames(&databases);
       for (std::vector<string16>::const_iterator db = databases.begin();
            db != databases.end(); ++db) {
         base::FilePath file_path =
             tracker_->GetFullDBFilePath(ori->GetOriginIdentifier(), *db);
         base::PlatformFileInfo file_info;
         if (file_util::GetFileInfo(file_path, &file_info)) {
           database_info_.push_back(DatabaseInfo(
-                web_security_origin.host().utf8(),
+                identifier,
                 UTF16ToUTF8(*db),
-                ori->GetOriginIdentifier(),
                 UTF16ToUTF8(ori->GetDatabaseDescription(*db)),
-                origin_url.spec(),
                 file_info.size,
                 file_info.last_modified));
         }
       }
     }
   }
 
   BrowserThread::PostTask(
       BrowserThread::UI, FROM_HERE,
       base::Bind(&BrowsingDataDatabaseHelper::NotifyInUIThread, this));
@@ skipping 40 matching lines @@
     Profile* profile)
     : BrowsingDataDatabaseHelper(profile),
       profile_(profile) {
 }
 
 CannedBrowsingDataDatabaseHelper* CannedBrowsingDataDatabaseHelper::Clone() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   CannedBrowsingDataDatabaseHelper* clone =
       new CannedBrowsingDataDatabaseHelper(profile_);
 
-  base::AutoLock auto_lock(lock_);
   clone->pending_database_info_ = pending_database_info_;
   return clone;
 }
 
 void CannedBrowsingDataDatabaseHelper::AddDatabase(
     const GURL& origin,
     const std::string& name,
     const std::string& description) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
-  base::AutoLock auto_lock(lock_);
   if (BrowsingDataHelper::HasWebScheme(origin)) {
     pending_database_info_.insert(PendingDatabaseInfo(
           origin, name, description));
   }
 }
 
 void CannedBrowsingDataDatabaseHelper::Reset() {
-  base::AutoLock auto_lock(lock_);
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   pending_database_info_.clear();
 }
 
 bool CannedBrowsingDataDatabaseHelper::empty() const {
-  base::AutoLock auto_lock(lock_);
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   return pending_database_info_.empty();
 }
 
 size_t CannedBrowsingDataDatabaseHelper::GetDatabaseCount() const {
-  base::AutoLock auto_lock(lock_);
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   return pending_database_info_.size();
 }
 
 const std::set<CannedBrowsingDataDatabaseHelper::PendingDatabaseInfo>&
 CannedBrowsingDataDatabaseHelper::GetPendingDatabaseInfo() {
   return pending_database_info_;
 }
 
 void CannedBrowsingDataDatabaseHelper::StartFetching(
     const base::Callback<void(const std::list<DatabaseInfo>&)>& 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(&CannedBrowsingDataDatabaseHelper::ConvertInfoInWebKitThread,
-                 this));
-}
 
-CannedBrowsingDataDatabaseHelper::~CannedBrowsingDataDatabaseHelper() {}
-
-void CannedBrowsingDataDatabaseHelper::ConvertInfoInWebKitThread() {
-  base::AutoLock auto_lock(lock_);
   database_info_.clear();
   for (std::set<PendingDatabaseInfo>::const_iterator
        info = pending_database_info_.begin();
        info != pending_database_info_.end(); ++info) {
-    WebSecurityOrigin web_security_origin =
-        WebSecurityOrigin::createFromString(

[michaeln, 2013/06/19 23:28:29]

this was silly code, there was never really a need to do this work on the webkit
thread

-            UTF8ToUTF16(info->origin.spec()));
-    std::string origin_identifier =
-        web_security_origin.databaseIdentifier().utf8();
+    DatabaseIdentifier identifier =
+        DatabaseIdentifier::CreateFromOrigin(info->origin);
 
     database_info_.push_back(DatabaseInfo(
-        web_security_origin.host().utf8(),
+        identifier,
         info->name,
-        origin_identifier,
         info->description,
-        web_security_origin.toString().utf8(),
         0,
         base::Time()));
   }
 
   BrowserThread::PostTask(

[jamesr, 2013/06/19 22:12:48]

this still PostTask()s to its own thread just to keep StartFetching
asynchronous.  I'm not sure this is really necessary - we can construct a
DatabaseInfo set from origins directly on the UI thread.  Since
CannedBrowsingDataDatabaseHelper is a subclass of BDDH, which has to do
StartFetching() asynchronously since it touches the file thread, it wasn't
totally clear if this could just be nuked.

[michaeln, 2013/06/19 23:28:29]

we should keep the behavior async so this mock exhibits the same behavior

       BrowserThread::UI, FROM_HERE,
       base::Bind(&CannedBrowsingDataDatabaseHelper::NotifyInUIThread, this));
 }
+
+CannedBrowsingDataDatabaseHelper::~CannedBrowsingDataDatabaseHelper() {}