content/common/web_database_observer_impl.cc

   1 // Copyright (c) 2011 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/WebKit/Source/WebKit/chromium/public/WebDatabase.h"
  11 #include "third_party/WebKit/Source/WebKit/chromium/public/platform/WebString.h"
  12
  13 using WebKit::WebDatabase;
  14
  15 namespace {
  16
  17 const int kResultHistogramSize = 50;
  18 const int kCallsiteHistogramSize = 10;
  19
  20 int DetermineHistogramResult(int websql_error, int sqlite_error) {
  21   // If we have a sqlite error, log it after trimming the extended bits.
  22   // There are 26 possible values, but we leave room for some new ones.
  23   if (sqlite_error)
  24     return std::min(sqlite_error & 0xff, 30);
  25
  26   // Otherwise, websql_error may be an SQLExceptionCode, SQLErrorCode
  27   // or a DOMExceptionCode, or -1 for success.
  28   if (websql_error == -1)
  29     return 0;  // no error
  30
  31   // SQLExceptionCode starts at 1000
  32   if (websql_error >= 1000)
  33     websql_error -= 1000;
  34
  35   return std::min(websql_error + 30, kResultHistogramSize - 1);
  36 }
  37
  38 #define HISTOGRAM_WEBSQL_RESULT(name, database, callsite, \
  39                                 websql_error, sqlite_error) \
  40   do { \
  41     DCHECK(callsite < kCallsiteHistogramSize); \
  42     int result = DetermineHistogramResult(websql_error, sqlite_error); \
  43     if (database.isSyncDatabase()) { \
  44       UMA_HISTOGRAM_ENUMERATION("websql.Sync." name, \
  45                                 result, kResultHistogramSize); \
  46       if (result) { \
  47         UMA_HISTOGRAM_ENUMERATION("websql.Sync." name ".ErrorSite", \
  48                                   callsite, kCallsiteHistogramSize); \
  49       } \
  50     } else { \
  51       UMA_HISTOGRAM_ENUMERATION("websql.Async." name, \
  52                                 result, kResultHistogramSize); \
  53       if (result) { \
  54         UMA_HISTOGRAM_ENUMERATION("websql.Async." name ".ErrorSite", \
  55                                   callsite, kCallsiteHistogramSize); \
  56       } \
  57     } \
  58   } while (0)
  59
  60 }  // namespace
  61
  62 WebDatabaseObserverImpl::WebDatabaseObserverImpl(
  63     IPC::Message::Sender* sender)
  64     : sender_(sender),
  65       open_connections_(new webkit_database::DatabaseConnectionsWrapper) {
  66 }
  67
  68 WebDatabaseObserverImpl::~WebDatabaseObserverImpl() {
  69 }
  70
  71 void WebDatabaseObserverImpl::databaseOpened(
  72     const WebDatabase& database) {
  73   string16 origin_identifier = database.securityOrigin().databaseIdentifier();
  74   string16 database_name = database.name();
  75   open_connections_->AddOpenConnection(origin_identifier, database_name);
  76   sender_->Send(new DatabaseHostMsg_Opened(
  77       origin_identifier, database_name,
  78       database.displayName(), database.estimatedSize()));
  79 }
  80
  81 void WebDatabaseObserverImpl::databaseModified(
  82     const WebDatabase& database) {
  83   sender_->Send(new DatabaseHostMsg_Modified(
  84       database.securityOrigin().databaseIdentifier(), database.name()));
  85 }
  86
  87 void WebDatabaseObserverImpl::databaseClosed(
  88     const WebDatabase& database) {
  89   string16 origin_identifier = database.securityOrigin().databaseIdentifier();
  90   string16 database_name = database.name();
  91   sender_->Send(new DatabaseHostMsg_Closed(
  92       origin_identifier, database_name));
  93   open_connections_->RemoveOpenConnection(origin_identifier, database_name);
  94 }
  95
  96 void WebDatabaseObserverImpl::reportOpenDatabaseResult(
  97     const WebDatabase& database, int callsite, int websql_error,
  98     int sqlite_error) {
  99   HISTOGRAM_WEBSQL_RESULT("OpenResult", database, callsite,
 100                           websql_error, sqlite_error);
 101 }
 102
 103 void WebDatabaseObserverImpl::reportChangeVersionResult(
 104     const WebDatabase& database, int callsite, int websql_error,
 105     int sqlite_error) {
 106   HISTOGRAM_WEBSQL_RESULT("ChangeVersionResult", database, callsite,
 107                           websql_error, sqlite_error);
 108 }
 109
 110 void WebDatabaseObserverImpl::reportStartTransactionResult(
 111     const WebDatabase& database, int callsite, int websql_error,
 112     int sqlite_error) {
 113   HISTOGRAM_WEBSQL_RESULT("BeginResult", database, callsite,
 114                           websql_error, sqlite_error);
 115 }
 116
 117 void WebDatabaseObserverImpl::reportCommitTransactionResult(
 118     const WebDatabase& database, int callsite, int websql_error,
 119     int sqlite_error) {
 120   HISTOGRAM_WEBSQL_RESULT("CommitResult", database, callsite,
 121                           websql_error, sqlite_error);
 122 }
 123
 124 void WebDatabaseObserverImpl::reportExecuteStatementResult(
 125     const WebDatabase& database, int callsite, int websql_error,
 126     int sqlite_error) {
 127   HISTOGRAM_WEBSQL_RESULT("StatementResult", database, callsite,
 128                           websql_error, sqlite_error);
 129 }
 130
 131 void WebDatabaseObserverImpl::reportVacuumDatabaseResult(
 132     const WebDatabase& database, int sqlite_error) {
 133   int result = DetermineHistogramResult(-1, sqlite_error);
 134   if (database.isSyncDatabase()) {
 135     UMA_HISTOGRAM_ENUMERATION("websql.Sync.VacuumResult",
 136                               result, kResultHistogramSize);
 137   } else {
 138     UMA_HISTOGRAM_ENUMERATION("websql.Async.VacuumResult",
 139                               result, kResultHistogramSize);
 140   }
 141 }
 142
 143 void WebDatabaseObserverImpl::WaitForAllDatabasesToClose() {
 144   open_connections_->WaitForAllDatabasesToClose();
 145 }