content/common/web_database_observer_impl.cc

   1 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "content/common/web_database_observer_impl.h"
   6
   7 #include "base/metrics/histogram.h"
   8 #include "base/string16.h"
   9 #include "content/common/database_messages.h"
  10 #include "third_party/sqlite/sqlite3.h"
  11 #include "third_party/WebKit/Source/WebKit/chromium/public/WebDatabase.h"
  12 #include "third_party/WebKit/Source/WebKit/chromium/public/platform/WebString.h"
  13
  14 using WebKit::WebDatabase;
  15
  16 namespace content {
  17 namespace {
  18
  19 const int kResultHistogramSize = 50;
  20 const int kCallsiteHistogramSize = 10;
  21
  22 int DetermineHistogramResult(int websql_error, int sqlite_error) {
  23   // If we have a sqlite error, log it after trimming the extended bits.
  24   // There are 26 possible values, but we leave room for some new ones.
  25   if (sqlite_error)
  26     return std::min(sqlite_error & 0xff, 30);
  27
  28   // Otherwise, websql_error may be an SQLExceptionCode, SQLErrorCode
  29   // or a DOMExceptionCode, or -1 for success.
  30   if (websql_error == -1)
  31     return 0;  // no error
  32
  33   // SQLExceptionCode starts at 1000
  34   if (websql_error >= 1000)
  35     websql_error -= 1000;
  36
  37   return std::min(websql_error + 30, kResultHistogramSize - 1);
  38 }
  39
  40 #define HISTOGRAM_WEBSQL_RESULT(name, database, callsite, \
  41                                 websql_error, sqlite_error) \
  42   do { \
  43     DCHECK(callsite < kCallsiteHistogramSize); \
  44     int result = DetermineHistogramResult(websql_error, sqlite_error); \
  45     if (database.isSyncDatabase()) { \
  46       UMA_HISTOGRAM_ENUMERATION("websql.Sync." name, \
  47                                 result, kResultHistogramSize); \
  48       if (result) { \
  49         UMA_HISTOGRAM_ENUMERATION("websql.Sync." name ".ErrorSite", \
  50                                   callsite, kCallsiteHistogramSize); \
  51       } \
  52     } else { \
  53       UMA_HISTOGRAM_ENUMERATION("websql.Async." name, \
  54                                 result, kResultHistogramSize); \
  55       if (result) { \
  56         UMA_HISTOGRAM_ENUMERATION("websql.Async." name ".ErrorSite", \
  57                                   callsite, kCallsiteHistogramSize); \
  58       } \
  59     } \
  60   } while (0)
  61
  62 }  // namespace
  63
  64 WebDatabaseObserverImpl::WebDatabaseObserverImpl(
  65     IPC::SyncMessageFilter* sender)
  66     : sender_(sender),
  67       open_connections_(new webkit_database::DatabaseConnectionsWrapper) {
  68   DCHECK(sender);
  69 }
  70
  71 WebDatabaseObserverImpl::~WebDatabaseObserverImpl() {
  72 }
  73
  74 void WebDatabaseObserverImpl::databaseOpened(
  75     const WebDatabase& database) {
  76   string16 origin_identifier = database.securityOrigin().databaseIdentifier();
  77   string16 database_name = database.name();
  78   open_connections_->AddOpenConnection(origin_identifier, database_name);
  79   sender_->Send(new DatabaseHostMsg_Opened(
  80       origin_identifier, database_name,
  81       database.displayName(), database.estimatedSize()));
  82 }
  83
  84 void WebDatabaseObserverImpl::databaseModified(
  85     const WebDatabase& database) {
  86   sender_->Send(new DatabaseHostMsg_Modified(
  87       database.securityOrigin().databaseIdentifier(), database.name()));
  88 }
  89
  90 void WebDatabaseObserverImpl::databaseClosed(
  91     const WebDatabase& database) {
  92   string16 origin_identifier = database.securityOrigin().databaseIdentifier();
  93   string16 database_name = database.name();
  94   sender_->Send(new DatabaseHostMsg_Closed(
  95       origin_identifier, database_name));
  96   open_connections_->RemoveOpenConnection(origin_identifier, database_name);
  97 }
  98
  99 void WebDatabaseObserverImpl::reportOpenDatabaseResult(
 100     const WebDatabase& database, int callsite, int websql_error,
 101     int sqlite_error) {
 102   HISTOGRAM_WEBSQL_RESULT("OpenResult", database, callsite,
 103                           websql_error, sqlite_error);
 104   HandleSqliteError(database, sqlite_error);
 105 }
 106
 107 void WebDatabaseObserverImpl::reportChangeVersionResult(
 108     const WebDatabase& database, int callsite, int websql_error,
 109     int sqlite_error) {
 110   HISTOGRAM_WEBSQL_RESULT("ChangeVersionResult", database, callsite,
 111                           websql_error, sqlite_error);
 112   HandleSqliteError(database, sqlite_error);
 113 }
 114
 115 void WebDatabaseObserverImpl::reportStartTransactionResult(
 116     const WebDatabase& database, int callsite, int websql_error,
 117     int sqlite_error) {
 118   HISTOGRAM_WEBSQL_RESULT("BeginResult", database, callsite,
 119                           websql_error, sqlite_error);
 120   HandleSqliteError(database, sqlite_error);
 121 }
 122
 123 void WebDatabaseObserverImpl::reportCommitTransactionResult(
 124     const WebDatabase& database, int callsite, int websql_error,
 125     int sqlite_error) {
 126   HISTOGRAM_WEBSQL_RESULT("CommitResult", database, callsite,
 127                           websql_error, sqlite_error);
 128   HandleSqliteError(database, sqlite_error);
 129 }
 130
 131 void WebDatabaseObserverImpl::reportExecuteStatementResult(
 132     const WebDatabase& database, int callsite, int websql_error,
 133     int sqlite_error) {
 134   HISTOGRAM_WEBSQL_RESULT("StatementResult", database, callsite,
 135                           websql_error, sqlite_error);
 136   HandleSqliteError(database, sqlite_error);
 137 }
 138
 139 void WebDatabaseObserverImpl::reportVacuumDatabaseResult(
 140     const WebDatabase& database, int sqlite_error) {
 141   int result = DetermineHistogramResult(-1, sqlite_error);
 142   if (database.isSyncDatabase()) {
 143     UMA_HISTOGRAM_ENUMERATION("websql.Sync.VacuumResult",
 144                               result, kResultHistogramSize);
 145   } else {
 146     UMA_HISTOGRAM_ENUMERATION("websql.Async.VacuumResult",
 147                               result, kResultHistogramSize);
 148   }
 149   HandleSqliteError(database, sqlite_error);
 150 }
 151
 152 void WebDatabaseObserverImpl::WaitForAllDatabasesToClose() {
 153   open_connections_->WaitForAllDatabasesToClose();
 154 }
 155
 156 void WebDatabaseObserverImpl::HandleSqliteError(
 157     const WebDatabase& database, int error) {
 158   // We filter out errors which the backend doesn't act on to avoid
 159   // a unnecessary ipc traffic, this method can get called at a fairly
 160   // high frequency (per-sqlstatement).
 161   if (error == SQLITE_CORRUPT || error == SQLITE_NOTADB) {
 162     sender_->Send(new DatabaseHostMsg_HandleSqliteError(
 163         database.securityOrigin().databaseIdentifier(),
 164         database.name(),
 165         error));
 166   }
 167 }
 168
 169 }  // namespace content