Add various UMA histograms for measuring GCM crypto performance

components/gcm_driver/gcm_driver_desktop.cc

 // Copyright 2014 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/gcm_driver_desktop.h"
 
 #include <utility>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
@@ skipping 90 matching lines @@
   void GetInstanceIDData(const std::string& app_id);
   void GetToken(const std::string& app_id,
                 const std::string& authorized_entity,
                 const std::string& scope,
                 const std::map<std::string, std::string>& options);
   void DeleteToken(const std::string& app_id,
                    const std::string& authorized_entity,
                    const std::string& scope);
 
   void RecordDecryptionFailure(const std::string& app_id,
-                               GCMEncryptionProvider::DecryptionFailure reason);
+                               GCMEncryptionProvider::DecryptionResult result);
 
   // For testing purpose. Can be called from UI thread. Use with care.
   GCMClient* gcm_client_for_testing() const { return gcm_client_.get(); }
 
  private:
   scoped_refptr<base::SequencedTaskRunner> ui_thread_;
   scoped_refptr<base::SequencedTaskRunner> io_thread_;
 
   base::WeakPtr<GCMDriverDesktop> service_;
 
@@ skipping 372 matching lines @@
 }
 
 void GCMDriverDesktop::IOWorker::RemoveHeartbeatInterval(
     const std::string& scope) {
   DCHECK(io_thread_->RunsTasksOnCurrentThread());
   gcm_client_->RemoveHeartbeatInterval(scope);
 }
 
 void GCMDriverDesktop::IOWorker::RecordDecryptionFailure(
     const std::string& app_id,
-    GCMEncryptionProvider::DecryptionFailure reason) {
+    GCMEncryptionProvider::DecryptionResult result) {
   DCHECK(io_thread_->RunsTasksOnCurrentThread());
-  gcm_client_->RecordDecryptionFailure(app_id, reason);
+  gcm_client_->RecordDecryptionFailure(app_id, result);
 }
 
 GCMDriverDesktop::GCMDriverDesktop(
     scoped_ptr<GCMClientFactory> gcm_client_factory,
     const GCMClient::ChromeBuildInfo& chrome_build_info,
     const std::string& channel_status_request_url,
     const std::string& user_agent,
     PrefService* prefs,
     const base::FilePath& store_path,
     const scoped_refptr<net::URLRequestContextGetter>& request_context,
@@ skipping 210 matching lines @@
       FROM_HERE,
       base::Bind(&GCMDriverDesktop::IOWorker::Send,
                  base::Unretained(io_worker_.get()),
                  app_id,
                  receiver_id,
                  message));
 }
 
 void GCMDriverDesktop::RecordDecryptionFailure(
     const std::string& app_id,
-    GCMEncryptionProvider::DecryptionFailure reason) {
+    GCMEncryptionProvider::DecryptionResult result) {
   DCHECK(ui_thread_->RunsTasksOnCurrentThread());
   io_thread_->PostTask(
       FROM_HERE,
       base::Bind(&GCMDriverDesktop::IOWorker::RecordDecryptionFailure,
                  base::Unretained(io_worker_.get()),
-                 app_id, reason));
+                 app_id, result));
 }
 
 GCMClient* GCMDriverDesktop::GetGCMClientForTesting() const {
   DCHECK(ui_thread_->RunsTasksOnCurrentThread());
   return io_worker_ ? io_worker_->gcm_client_for_testing() : NULL;
 }
 
 bool GCMDriverDesktop::IsStarted() const {
   DCHECK(ui_thread_->RunsTasksOnCurrentThread());
   return gcm_started_;
@@ skipping 568 matching lines @@
 
   if (base::get<1>(a) < base::get<1>(b))
     return true;
   if (base::get<1>(a) > base::get<1>(b))
     return false;
 
   return base::get<2>(a) < base::get<2>(b);
 }
 
 }  // namespace gcm