Remove content/browser dependency on WebKit::WebIDBCallbacks and WebKit::WebIDBDatabaseCallbacks

content/browser/indexed_db/indexed_db_context_impl.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 "content/browser/indexed_db/indexed_db_context_impl.h"
 
 #include <vector>
 
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/file_util.h"
 #include "base/files/file_enumerator.h"
 #include "base/logging.h"
 #include "base/message_loop/message_loop_proxy.h"
 #include "base/string_util.h"
 #include "base/strings/utf_string_conversions.h"
 #include "content/browser/indexed_db/indexed_db_quota_client.h"
+#include "content/browser/indexed_db/webidbdatabase_impl.h"
 #include "content/browser/indexed_db/webidbfactory_impl.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/indexed_db_info.h"
 #include "content/public/common/content_switches.h"
 #include "third_party/WebKit/public/platform/WebCString.h"
 #include "third_party/WebKit/public/platform/WebIDBDatabase.h"
-#include "third_party/WebKit/public/platform/WebIDBFactory.h"
 #include "third_party/WebKit/public/platform/WebString.h"
 #include "webkit/base/file_path_string_conversions.h"
 #include "webkit/base/origin_url_conversions.h"
 #include "webkit/browser/database/database_util.h"
 #include "webkit/browser/quota/quota_manager.h"
 #include "webkit/browser/quota/special_storage_policy.h"
 
 using webkit_database::DatabaseUtil;
-using WebKit::WebIDBDatabase;
-using WebKit::WebIDBFactory;
 
 namespace content {
 const base::FilePath::CharType IndexedDBContextImpl::kIndexedDBDirectory[] =
     FILE_PATH_LITERAL("IndexedDB");
 
 const base::FilePath::CharType IndexedDBContextImpl::kIndexedDBExtension[] =
     FILE_PATH_LITERAL(".leveldb");
 
 namespace {
 
@@ skipping 52 matching lines @@
       quota_manager_proxy_(quota_manager_proxy) {
   if (!data_path.empty())
     data_path_ = data_path.Append(kIndexedDBDirectory);
   if (quota_manager_proxy &&
       !CommandLine::ForCurrentProcess()->HasSwitch(switches::kSingleProcess)) {
     quota_manager_proxy->RegisterClient(
         new IndexedDBQuotaClient(webkit_thread_loop, this));
   }
 }
 
-WebIDBFactory* IndexedDBContextImpl::GetIDBFactory() {
+WebIDBFactoryImpl* IndexedDBContextImpl::GetIDBFactory() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::WEBKIT_DEPRECATED));
   if (!idb_factory_) {
     // Prime our cache of origins with existing databases so we can
     // detect when dbs are newly created.
     GetOriginSet();
     idb_factory_.reset(new content::WebIDBFactoryImpl());
   }
   return idb_factory_.get();
 }
 
@@ skipping 65 matching lines @@
 void IndexedDBContextImpl::ForceClose(const GURL& origin_url) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::WEBKIT_DEPRECATED));
   if (data_path_.empty() || !IsInOriginSet(origin_url))
     return;
 
   if (connections_.find(origin_url) != connections_.end()) {
     ConnectionSet& connections = connections_[origin_url];
     ConnectionSet::iterator it = connections.begin();
     while (it != connections.end()) {
       // Remove before closing so callbacks don't double-erase
-      WebKit::WebIDBDatabase* db = *it;
+      WebIDBDatabaseImpl* db = *it;
       connections.erase(it++);
       db->forceClose();
     }
     DCHECK_EQ(connections_[origin_url].size(), 0UL);
     connections_.erase(origin_url);
   }
 }
 
 base::FilePath IndexedDBContextImpl::GetFilePath(const GURL& origin_url) {
   base::string16 origin_id =
       webkit_base::GetOriginIdentifierFromURL(origin_url);
   return GetIndexedDBFilePath(origin_id);
 }
 
 base::FilePath IndexedDBContextImpl::GetFilePathForTesting(
     const string16& origin_id) const {
   return GetIndexedDBFilePath(origin_id);
 }
 
 void IndexedDBContextImpl::ConnectionOpened(const GURL& origin_url,
-                                            WebIDBDatabase* connection) {
+                                            WebIDBDatabaseImpl* connection) {
   DCHECK_EQ(connections_[origin_url].count(connection), 0UL);
   if (quota_manager_proxy()) {
     quota_manager_proxy()->NotifyStorageAccessed(
         quota::QuotaClient::kIndexedDatabase,
         origin_url,
         quota::kStorageTypeTemporary);
   }
   connections_[origin_url].insert(connection);
   if (AddToOriginSet(origin_url)) {
     // A newly created db, notify the quota system.
     QueryDiskAndUpdateQuotaUsage(origin_url);
   } else {
     EnsureDiskUsageCacheInitialized(origin_url);
   }
   QueryAvailableQuota(origin_url);
 }
 
 void IndexedDBContextImpl::ConnectionClosed(const GURL& origin_url,
-                                            WebIDBDatabase* connection) {
+                                            WebIDBDatabaseImpl* connection) {
   // May not be in the map if connection was forced to close
   if (connections_.find(origin_url) == connections_.end() ||
       connections_[origin_url].count(connection) != 1)
     return;
   if (quota_manager_proxy()) {
     quota_manager_proxy()->NotifyStorageAccessed(
         quota::QuotaClient::kIndexedDatabase,
         origin_url,
         quota::kStorageTypeTemporary);
   }
@@ skipping 24 matching lines @@
 bool IndexedDBContextImpl::IsOverQuota(const GURL& origin_url) {
   const int kOneAdditionalByte = 1;
   return WouldBeOverQuota(origin_url, kOneAdditionalByte);
 }
 
 quota::QuotaManagerProxy* IndexedDBContextImpl::quota_manager_proxy() {
   return quota_manager_proxy_.get();
 }
 
 IndexedDBContextImpl::~IndexedDBContextImpl() {
-  WebKit::WebIDBFactory* factory = idb_factory_.release();
+  WebIDBFactoryImpl* factory = idb_factory_.release();
   if (factory) {
     if (!BrowserThread::DeleteSoon(
             BrowserThread::WEBKIT_DEPRECATED, FROM_HERE, factory))
       delete factory;
   }
 
   if (data_path_.empty())
     return;
 
   if (force_keep_session_state_)
@@ skipping 119 matching lines @@
   return origin_set_.get();
 }
 
 void IndexedDBContextImpl::ResetCaches() {
   origin_set_.reset();
   origin_size_map_.clear();
   space_available_map_.clear();
 }
 
 }  // namespace content