Add various UMA histograms for measuring GCM crypto performance

components/gcm_driver/crypto/gcm_key_store.cc

 // Copyright 2015 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 "components/gcm_driver/crypto/gcm_key_store.h"
 
 #include <stddef.h>
 
 #include <utility>
 
 #include "base/logging.h"
+#include "base/metrics/histogram_macros.h"
 #include "components/gcm_driver/crypto/p256_key_util.h"
 #include "components/leveldb_proto/proto_database_impl.h"
 #include "crypto/random.h"
 
 namespace gcm {
 
 // Statistics are logged to UMA with this string as part of histogram name. They
 // can all be found under LevelDB.*.GCMKeyStore. Changing this needs to
 // synchronize with histograms.xml, AND will also become incompatible with older
 // browsers still reporting the previous values.
@@ skipping 25 matching lines @@
 void GCMKeyStore::GetKeys(const std::string& app_id,
                           const KeysCallback& callback) {
   LazyInitialize(base::Bind(&GCMKeyStore::GetKeysAfterInitialize,
                             weak_factory_.GetWeakPtr(), app_id, callback));
 }
 
 void GCMKeyStore::GetKeysAfterInitialize(const std::string& app_id,
                                          const KeysCallback& callback) {
   DCHECK(state_ == State::INITIALIZED || state_ == State::FAILED);
   const auto& iter = key_pairs_.find(app_id);
-  if (iter == key_pairs_.end() || state_ != State::INITIALIZED) {
+
+  const bool success = state_ == State::INITIALIZED && iter != key_pairs_.end();
+  UMA_HISTOGRAM_BOOLEAN("GCM.Crypto.GetKeySuccessRate", success);
+
+  if (!success) {
     callback.Run(KeyPair(), std::string() /* auth_secret */);
     return;
   }
 
   const auto& auth_secret_iter = auth_secrets_.find(app_id);
   DCHECK(auth_secret_iter != auth_secrets_.end());
 
   callback.Run(iter->second, auth_secret_iter->second);
 }
 
@@ skipping 53 matching lines @@
       std::move(entries_to_save), std::move(keys_to_remove),
       base::Bind(&GCMKeyStore::DidStoreKeys, weak_factory_.GetWeakPtr(), app_id,
                  *pair, auth_secret, callback));
 }
 
 void GCMKeyStore::DidStoreKeys(const std::string& app_id,
                                const KeyPair& pair,
                                const std::string& auth_secret,
                                const KeysCallback& callback,
                                bool success) {
+  UMA_HISTOGRAM_BOOLEAN("GCM.Crypto.CreateKeySuccessRate", success);
   DCHECK_EQ(0u, key_pairs_.count(app_id));
 
   if (!success) {
     DVLOG(1) << "Unable to store the created key in the GCM Key Store.";
     callback.Run(KeyPair(), std::string() /* auth_secret */);
     return;
   }
 
   key_pairs_[app_id] = pair;
   auth_secrets_[app_id] = auth_secret;
@@ skipping 25 matching lines @@
 
   database_->UpdateEntries(
       std::move(entries_to_save), std::move(keys_to_remove),
       base::Bind(&GCMKeyStore::DidRemoveKeys, weak_factory_.GetWeakPtr(),
                  app_id, callback));
 }
 
 void GCMKeyStore::DidRemoveKeys(const std::string& app_id,
                                 const base::Closure& callback,
                                 bool success) {
-  // TODO(peter): Add a histogram for tracking |success|.
+  UMA_HISTOGRAM_BOOLEAN("GCM.Crypto.RemoveKeySuccessRate", success);
 
   if (success) {
     key_pairs_.erase(app_id);
     auth_secrets_.erase(app_id);
   } else {
     DVLOG(1) << "Unable to delete a key from the GCM Key Store.";
   }
 
   callback.Run();
 }
@@ skipping 12 matching lines @@
 
   database_.reset(new leveldb_proto::ProtoDatabaseImpl<EncryptionData>(
       blocking_task_runner_));
 
   database_->Init(
       kDatabaseUMAClientName, key_store_path_,
       base::Bind(&GCMKeyStore::DidInitialize, weak_factory_.GetWeakPtr()));
 }
 
 void GCMKeyStore::DidInitialize(bool success) {
+  UMA_HISTOGRAM_BOOLEAN("GCM.Crypto.InitKeyStoreSuccessRate", success);
   if (!success) {
     DVLOG(1) << "Unable to initialize the GCM Key Store.";
     state_ = State::FAILED;
 
     delayed_task_controller_.SetReady();
     return;
   }
 
   database_->LoadEntries(
       base::Bind(&GCMKeyStore::DidLoadKeys, weak_factory_.GetWeakPtr()));
 }
 
 void GCMKeyStore::DidLoadKeys(bool success,
                               scoped_ptr<std::vector<EncryptionData>> entries) {
+  UMA_HISTOGRAM_BOOLEAN("GCM.Crypto.LoadKeyStoreSuccessRate", success);
   if (!success) {
     DVLOG(1) << "Unable to load entries into the GCM Key Store.";
     state_ = State::FAILED;
 
     delayed_task_controller_.SetReady();
     return;
   }
 
   for (const EncryptionData& entry : *entries) {
     DCHECK_EQ(1, entry.keys_size());
 
     key_pairs_[entry.app_id()] = entry.keys(0);
     auth_secrets_[entry.app_id()] = entry.auth_secret();
   }
 
   state_ = State::INITIALIZED;
 
   delayed_task_controller_.SetReady();
 }
 
 }  // namespace gcm