[IndexedDB] Adding txn, value, and key size metrics

content/browser/indexed_db/database_impl.cc

 // Copyright 2016 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/database_impl.h"
 
 #include "base/memory/ptr_util.h"
 #include "base/metrics/histogram_macros.h"
+#include "base/numerics/safe_math.h"
 #include "base/sequenced_task_runner.h"
 #include "base/threading/thread_checker.h"
 #include "base/threading/thread_task_runner_handle.h"
 #include "content/browser/bad_message.h"
 #include "content/browser/child_process_security_policy_impl.h"
 #include "content/browser/indexed_db/indexed_db_connection.h"
 #include "content/browser/indexed_db/indexed_db_context_impl.h"
 #include "content/browser/indexed_db/indexed_db_dispatcher_host.h"
 #include "content/browser/indexed_db/indexed_db_transaction.h"
 #include "content/browser/indexed_db/indexed_db_value.h"
@@ skipping 255 matching lines @@
     ::indexed_db::mojom::CallbacksAssociatedPtrInfo callbacks_info) {
   ChildProcessSecurityPolicyImpl* policy =
       ChildProcessSecurityPolicyImpl::GetInstance();
 
   scoped_refptr<IndexedDBCallbacks> callbacks(
       new IndexedDBCallbacks(dispatcher_host_->AsWeakPtr(), origin_,
                              std::move(callbacks_info), idb_runner_));
 
   std::vector<std::unique_ptr<storage::BlobDataHandle>> handles(
       value->blob_or_file_info.size());
+  base::CheckedNumeric<uint64_t> total_blob_size = 0;
   std::vector<IndexedDBBlobInfo> blob_info(value->blob_or_file_info.size());
   for (size_t i = 0; i < value->blob_or_file_info.size(); ++i) {
     ::indexed_db::mojom::BlobInfoPtr& info = value->blob_or_file_info[i];
 
     std::unique_ptr<storage::BlobDataHandle> handle =
         dispatcher_host_->blob_storage_context()->GetBlobDataFromUUID(
             info->uuid);
 
     // Due to known issue crbug.com/351753, blobs can die while being passed to
     // a different process. So this case must be handled gracefully.
     // TODO(dmurph): Revert back to using mojo::ReportBadMessage once fixed.
     UMA_HISTOGRAM_BOOLEAN("Storage.IndexedDB.PutValidBlob",
                           handle.get() != nullptr);
     if (!handle) {
       IndexedDBDatabaseError error(blink::kWebIDBDatabaseExceptionUnknownError,
                                    kInvalidBlobUuid);
       idb_runner_->PostTask(
           FROM_HERE, base::Bind(&IDBThreadHelper::AbortWithError,
                                 base::Unretained(helper_), transaction_id,
                                 base::Passed(&callbacks), error));
       return;
     }
-    UMA_HISTOGRAM_MEMORY_KB("Storage.IndexedDB.PutBlobSizeKB",
-                            handle->size() / 1024ull);
-
+    uint64_t size = handle->size();
+    UMA_HISTOGRAM_MEMORY_KB("Storage.IndexedDB.PutBlobSizeKB", size / 1024ull);
+    total_blob_size += size;
     handles[i] = std::move(handle);
 
     if (info->file) {
       if (!info->file->path.empty() &&
           !policy->CanReadFile(dispatcher_host_->ipc_process_id(),
                                info->file->path)) {
         mojo::ReportBadMessage(kInvalidBlobFilePath);
         return;
       }
       blob_info[i] = IndexedDBBlobInfo(info->uuid, info->file->path,
                                        info->file->name, info->mime_type);
       if (info->size != -1) {
         blob_info[i].set_last_modified(info->file->last_modified);
         blob_info[i].set_size(info->size);
       }
     } else {
       blob_info[i] = IndexedDBBlobInfo(info->uuid, info->mime_type, info->size);
     }
   }
-
+  UMA_HISTOGRAM_COUNTS_1000("WebCore.IndexedDB.PutBlobsCount",
+                            blob_info.size());
+  uint64_t blob_size = 0;
+  total_blob_size.AssignIfValid(&blob_size);
+  if (blob_size != 0) {
+    // 1KB to 1GB.
+    UMA_HISTOGRAM_COUNTS_1M("WebCore.IndexedDB.PutBlobsTotalSize",
+                            blob_size / 1024);
+  }
   idb_runner_->PostTask(
       FROM_HERE,
       base::Bind(&IDBThreadHelper::Put, base::Unretained(helper_),
                  transaction_id, object_store_id, base::Passed(&value),
                  base::Passed(&handles), base::Passed(&blob_info), key, mode,
                  index_keys, base::Passed(&callbacks)));
 }
 
 void DatabaseImpl::SetIndexKeys(
     int64_t transaction_id,
@@ skipping 315 matching lines @@
     scoped_refptr<IndexedDBCallbacks> callbacks) {
   DCHECK(idb_thread_checker_.CalledOnValidThread());
   if (!connection_->IsConnected())
     return;
 
   IndexedDBTransaction* transaction =
       connection_->GetTransaction(transaction_id);
   if (!transaction)
     return;
 
-  uint64_t commit_size = mojo_value->bits.size();
+  // Value size recorded in IDBObjectStore before we can auto-wrap in a blob.
+  // 1KB to 10MB.
+  UMA_HISTOGRAM_COUNTS_10000("WebCore.IndexedDB.PutKeySize",
+                             key.size_estimate() / 1024);
+
+  uint64_t commit_size = mojo_value->bits.size() + key.size_estimate();
   IndexedDBValue value;
   swap(value.bits, mojo_value->bits);
   swap(value.blob_info, blob_info);
   connection_->database()->Put(transaction, object_store_id, &value, &handles,
                                base::MakeUnique<IndexedDBKey>(key), mode,
                                std::move(callbacks), index_keys);
 
   // Size can't be big enough to overflow because it represents the
   // actual bytes passed through IPC.
   transaction->set_size(transaction->size() + commit_size);
@@ skipping 241 matching lines @@
       usage + transaction->size() <= quota) {
     connection_->database()->Commit(transaction);
   } else {
     connection_->AbortTransaction(
         transaction,
         IndexedDBDatabaseError(blink::kWebIDBDatabaseExceptionQuotaError));
   }
 }
 
 }  // namespace content