Change WebDatabaseObserverImpl to implement public/platform's WebDatabaseObserver

I'm trying to fix DatabaseObserver layering issue in blink and
am going to move WebDatabaseObserver from public/web to
public/platform.

Depends on blink side patches:
part 1: https://codereview.chromium.org/64353002/ (landed)
part 2: https://codereview.chromium.org/59423003/

BUG=none
TEST=layout_tests

Review URL: https://codereview.chromium.org/66823002

git-svn-id: svn://svn.chromium.org/chrome/trunk/src@234602 0039d316-1c4b-4281-b951-d872f2087c98

2 files changed, 108 insertions, 82 deletions

diff --git a/content/child/web_database_observer_impl.cc b/content/child/web_database_observer_impl.cc
index d47dfb8..f06823e 100644
--- a/content/child/web_database_observer_impl.cc
+++ b/content/child/web_database_observer_impl.cc
@@ -9,13 +9,12 @@
 #include "content/common/database_messages.h"
 #include "third_party/WebKit/public/platform/WebCString.h"
 #include "third_party/WebKit/public/platform/WebString.h"
-#include "third_party/WebKit/public/web/WebDatabase.h"
 #include "third_party/sqlite/sqlite3.h"
 
-using blink::WebDatabase;
 using blink::WebString;
 
 namespace content {
+
 namespace {
 
 const int kResultHistogramSize = 50;
@@ -39,12 +38,12 @@ int DetermineHistogramResult(int websql_error, int sqlite_error) {
   return std::min(websql_error + 30, kResultHistogramSize - 1);
 }
 
-#define HISTOGRAM_WEBSQL_RESULT(name, database, callsite, \
-                                websql_error, sqlite_error) \
+#define HISTOGRAM_WEBSQL_RESULT(name, is_sync_database, \
+                                callsite, websql_error, sqlite_error) \
   do { \
     DCHECK(callsite < kCallsiteHistogramSize); \
     int result = DetermineHistogramResult(websql_error, sqlite_error); \
-    if (database.isSyncDatabase()) { \
+    if (is_sync_database) { \
       UMA_HISTOGRAM_ENUMERATION("websql.Sync." name, \
                                 result, kResultHistogramSize); \
       if (result) { \
@@ -74,91 +73,97 @@ WebDatabaseObserverImpl::~WebDatabaseObserverImpl() {
 }
 
 void WebDatabaseObserverImpl::databaseOpened(
-    const WebDatabase& database) {
-  std::string origin_identifier =
-      database.securityOrigin().databaseIdentifier().utf8();
-  string16 database_name = database.name();
-  open_connections_->AddOpenConnection(origin_identifier, database_name);
+    const WebString& origin_identifier,
+    const WebString& database_name,
+    const WebString& database_display_name,
+    unsigned long estimated_size) {
+  open_connections_->AddOpenConnection(origin_identifier.utf8(),
+                                       database_name);
   sender_->Send(new DatabaseHostMsg_Opened(
-      origin_identifier, database_name,
-      database.displayName(), database.estimatedSize()));
+      origin_identifier.utf8(), database_name,
+      database_display_name, estimated_size));
 }
 
 void WebDatabaseObserverImpl::databaseModified(
-    const WebDatabase& database) {
+    const WebString& origin_identifier,
+    const WebString& database_name) {
   sender_->Send(new DatabaseHostMsg_Modified(
-      database.securityOrigin().databaseIdentifier().utf8(), database.name()));
+      origin_identifier.utf8(), database_name));
 }
 
-void WebDatabaseObserverImpl::databaseClosed(const WebString& origin_identifier,
-                                             const WebString& database_name) {
+void WebDatabaseObserverImpl::databaseClosed(
+    const WebString& origin_identifier,
+    const WebString& database_name) {
   sender_->Send(new DatabaseHostMsg_Closed(
       origin_identifier.utf8(), database_name));
   open_connections_->RemoveOpenConnection(origin_identifier.utf8(),
                                           database_name);
 }
 
-void WebDatabaseObserverImpl::databaseClosed(
-    const WebDatabase& database) {
-  std::string origin_identifier =
-      database.securityOrigin().databaseIdentifier().utf8();
-  string16 database_name = database.name();
-  sender_->Send(new DatabaseHostMsg_Closed(
-      origin_identifier, database_name));
-  open_connections_->RemoveOpenConnection(origin_identifier, database_name);
-}
-
 void WebDatabaseObserverImpl::reportOpenDatabaseResult(
-    const WebDatabase& database, int callsite, int websql_error,
-    int sqlite_error) {
-  HISTOGRAM_WEBSQL_RESULT("OpenResult", database, callsite,
-                          websql_error, sqlite_error);
-  HandleSqliteError(database, sqlite_error);
+    const WebString& origin_identifier,
+    const WebString& database_name,
+    bool is_sync_database,
+    int callsite, int websql_error, int sqlite_error) {
+  HISTOGRAM_WEBSQL_RESULT("OpenResult", is_sync_database,
+                          callsite, websql_error, sqlite_error);
+  HandleSqliteError(origin_identifier, database_name, sqlite_error);
 }
 
 void WebDatabaseObserverImpl::reportChangeVersionResult(
-    const WebDatabase& database, int callsite, int websql_error,
-    int sqlite_error) {
-  HISTOGRAM_WEBSQL_RESULT("ChangeVersionResult", database, callsite,
-                          websql_error, sqlite_error);
-  HandleSqliteError(database, sqlite_error);
+    const WebString& origin_identifier,
+    const WebString& database_name,
+    bool is_sync_database,
+    int callsite, int websql_error, int sqlite_error) {
+  HISTOGRAM_WEBSQL_RESULT("ChangeVersionResult", is_sync_database,
+                          callsite, websql_error, sqlite_error);
+  HandleSqliteError(origin_identifier, database_name, sqlite_error);
 }
 
 void WebDatabaseObserverImpl::reportStartTransactionResult(
-    const WebDatabase& database, int callsite, int websql_error,
-    int sqlite_error) {
-  HISTOGRAM_WEBSQL_RESULT("BeginResult", database, callsite,
-                          websql_error, sqlite_error);
-  HandleSqliteError(database, sqlite_error);
+    const WebString& origin_identifier,
+    const WebString& database_name,
+    bool is_sync_database,
+    int callsite, int websql_error, int sqlite_error) {
+  HISTOGRAM_WEBSQL_RESULT("BeginResult", is_sync_database,
+                          callsite, websql_error, sqlite_error);
+  HandleSqliteError(origin_identifier, database_name, sqlite_error);
 }
 
 void WebDatabaseObserverImpl::reportCommitTransactionResult(
-    const WebDatabase& database, int callsite, int websql_error,
-    int sqlite_error) {
-  HISTOGRAM_WEBSQL_RESULT("CommitResult", database, callsite,
-                          websql_error, sqlite_error);
-  HandleSqliteError(database, sqlite_error);
+    const WebString& origin_identifier,
+    const WebString& database_name,
+    bool is_sync_database,
+    int callsite, int websql_error, int sqlite_error) {
+  HISTOGRAM_WEBSQL_RESULT("CommitResult", is_sync_database,
+                          callsite, websql_error, sqlite_error);
+  HandleSqliteError(origin_identifier, database_name, sqlite_error);
 }
 
 void WebDatabaseObserverImpl::reportExecuteStatementResult(
-    const WebDatabase& database, int callsite, int websql_error,
-    int sqlite_error) {
-  HISTOGRAM_WEBSQL_RESULT("StatementResult", database, callsite,
-                          websql_error, sqlite_error);
-  HandleSqliteError(database, sqlite_error);
+    const WebString& origin_identifier,
+    const WebString& database_name,
+    bool is_sync_database,
+    int callsite, int websql_error, int sqlite_error) {
+  HISTOGRAM_WEBSQL_RESULT("StatementResult", is_sync_database,
+                          callsite, websql_error, sqlite_error);
+  HandleSqliteError(origin_identifier, database_name, sqlite_error);
 }
 
 void WebDatabaseObserverImpl::reportVacuumDatabaseResult(
-    const WebDatabase& database, int sqlite_error) {
+    const WebString& origin_identifier,
+    const WebString& database_name,
+    bool is_sync_database,
+    int sqlite_error) {
   int result = DetermineHistogramResult(-1, sqlite_error);
-  if (database.isSyncDatabase()) {
+  if (is_sync_database) {
     UMA_HISTOGRAM_ENUMERATION("websql.Sync.VacuumResult",
                               result, kResultHistogramSize);
   } else {
     UMA_HISTOGRAM_ENUMERATION("websql.Async.VacuumResult",
                               result, kResultHistogramSize);
   }
-  HandleSqliteError(database, sqlite_error);
+  HandleSqliteError(origin_identifier, database_name, sqlite_error);
 }
 
 void WebDatabaseObserverImpl::WaitForAllDatabasesToClose() {
@@ -166,14 +171,16 @@ void WebDatabaseObserverImpl::WaitForAllDatabasesToClose() {
 }
 
 void WebDatabaseObserverImpl::HandleSqliteError(
-    const WebDatabase& database, int error) {
+    const WebString& origin_identifier,
+    const WebString& database_name,
+    int error) {
   // We filter out errors which the backend doesn't act on to avoid
   // a unnecessary ipc traffic, this method can get called at a fairly
   // high frequency (per-sqlstatement).
   if (error == SQLITE_CORRUPT || error == SQLITE_NOTADB) {
     sender_->Send(new DatabaseHostMsg_HandleSqliteError(
-        database.securityOrigin().databaseIdentifier().utf8(),
-        database.name(),
+        origin_identifier.utf8(),
+        database_name,
         error));
   }
 }
diff --git a/content/child/web_database_observer_impl.h b/content/child/web_database_observer_impl.h
index 07fe1d9..05ca0ca 100644
--- a/content/child/web_database_observer_impl.h
+++ b/content/child/web_database_observer_impl.h
@@ -7,52 +7,71 @@
 
 #include "base/memory/ref_counted.h"
 #include "ipc/ipc_sync_message_filter.h"
-#include "third_party/WebKit/public/web/WebDatabaseObserver.h"
+#include "third_party/WebKit/public/platform/WebPlatformDatabaseObserver.h"
 #include "webkit/common/database/database_connections.h"
 
-namespace blink {
-class WebString;
-}
-
 namespace content {
 
-class WebDatabaseObserverImpl : public blink::WebDatabaseObserver {
+// TODO(kinuko): WebPlatformDatabaseObserver should be renamed to
+// WebDatabaseObserver once non-platform one is deprecated.
+class WebDatabaseObserverImpl : public blink::WebPlatformDatabaseObserver {
  public:
   explicit WebDatabaseObserverImpl(IPC::SyncMessageFilter* sender);
   virtual ~WebDatabaseObserverImpl();
 
-  virtual void databaseOpened(const blink::WebDatabase& database) OVERRIDE;
-  virtual void databaseModified(const blink::WebDatabase& database) OVERRIDE;
-  virtual void databaseClosed(const blink::WebString& origin_identifier,
-                              const blink::WebString& database_name);
-  // TODO(jochen): Remove this version once the blink side has rolled.
-  virtual void databaseClosed(const blink::WebDatabase& database);
-
+  virtual void databaseOpened(
+      const blink::WebString& origin_identifier,
+      const blink::WebString& database_name,
+      const blink::WebString& database_display_name,
+      unsigned long estimated_size);
+  virtual void databaseModified(
+      const blink::WebString& origin_identifier,
+      const blink::WebString& database_name);
+  virtual void databaseClosed(
+      const blink::WebString& origin_identifier,
+      const blink::WebString& database_name);
   virtual void reportOpenDatabaseResult(
-      const blink::WebDatabase& database, int callsite,
-      int websql_error, int sqlite_error) OVERRIDE;
+      const blink::WebString& origin_identifier,
+      const blink::WebString& database_name,
+      bool is_sync_database,
+      int callsite, int websql_error, int sqlite_error);
   virtual void reportChangeVersionResult(
-      const blink::WebDatabase& database, int callsite,
-      int websql_error, int sqlite_error) OVERRIDE;
+      const blink::WebString& origin_identifier,
+      const blink::WebString& database_name,
+      bool is_sync_database,
+      int callsite, int websql_error, int sqlite_error);
   virtual void reportStartTransactionResult(
-      const blink::WebDatabase& database, int callsite,
-      int websql_error, int sqlite_error) OVERRIDE;
+      const blink::WebString& origin_identifier,
+      const blink::WebString& database_name,
+      bool is_sync_database,
+      int callsite, int websql_error, int sqlite_error);
   virtual void reportCommitTransactionResult(
-      const blink::WebDatabase& database, int callsite,
-      int websql_error, int sqlite_error) OVERRIDE;
+      const blink::WebString& origin_identifier,
+      const blink::WebString& database_name,
+      bool is_sync_database,
+      int callsite, int websql_error, int sqlite_error);
   virtual void reportExecuteStatementResult(
-      const blink::WebDatabase& database, int callsite,
-      int websql_error, int sqlite_error) OVERRIDE;
+      const blink::WebString& origin_identifier,
+      const blink::WebString& database_name,
+      bool is_sync_database,
+      int callsite, int websql_error, int sqlite_error);
   virtual void reportVacuumDatabaseResult(
-      const blink::WebDatabase& database, int sqlite_error) OVERRIDE;
+      const blink::WebString& origin_identifier,
+      const blink::WebString& database_name,
+      bool is_sync_database,
+      int sqlite_error);
 
   void WaitForAllDatabasesToClose();
 
  private:
-  void HandleSqliteError(const blink::WebDatabase& database, int error);
+  void HandleSqliteError(const blink::WebString& origin_identifier,
+                         const blink::WebString& database_name,
+                         int error);
 
   scoped_refptr<IPC::SyncMessageFilter> sender_;
   scoped_refptr<webkit_database::DatabaseConnectionsWrapper> open_connections_;
+
+  DISALLOW_COPY_AND_ASSIGN(WebDatabaseObserverImpl);
 };
 
 }  // namespace content