Add various UMA histograms for measuring GCM crypto performance

components/gcm_driver/gcm_driver.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.h"
 
 #include <stddef.h>
 
 #include <algorithm>
 
 #include "base/bind.h"
 #include "base/files/file_path.h"
 #include "base/logging.h"
+#include "base/metrics/histogram_macros.h"
 #include "components/gcm_driver/gcm_app_handler.h"
 
 namespace gcm {
 
 namespace {
 
 const size_t kMaxSenders = 100;
 
 }  // namespace
 
@@ skipping 242 matching lines @@
 }
 
 void GCMDriver::ClearCallbacks() {
   register_callbacks_.clear();
   unregister_callbacks_.clear();
   send_callbacks_.clear();
 }
 
 void GCMDriver::DispatchMessage(const std::string& app_id,
                                 const IncomingMessage& message) {
-  if (!encryption_provider_.IsEncryptedMessage(message)) {
-    GetAppHandler(app_id)->OnMessage(app_id, message);
-    return;
+  encryption_provider_.DecryptMessage(
+      app_id, message, base::Bind(&GCMDriver::DispatchMessageInternal,
+                                  weak_ptr_factory_.GetWeakPtr(), app_id));
+}
+
+void GCMDriver::DispatchMessageInternal(
+    const std::string& app_id,
+    GCMEncryptionProvider::DecryptionResult result,
+    const IncomingMessage& message) {
+  UMA_HISTOGRAM_ENUMERATION("GCM.Crypto.DecryptMessageResult", result,
+                            GCMEncryptionProvider::DECRYPTION_RESULT_LAST + 1);

[Ilya Sherman, 2016/02/18 21:54:40]

Optional nit: I generally find it's a little easier to have a _COUNT entry
rather than a _LAST entry, as it lets you drop the "+ 1" here, and it's easier
to keep the _COUNT entry correctly up-to-date.

[johnme, 2016/02/19 10:24:13]

Do you mean as a separate integer, outside the enum (named
DECRYPTION_RESULT_COUNT to match)? Having it in the enum would make it slightly
awkward to use the enum in switch statements.

+
+  switch (result) {
+    case GCMEncryptionProvider::DECRYPTION_RESULT_UNENCRYPTED:
+    case GCMEncryptionProvider::DECRYPTION_RESULT_DECRYPTED:
+      GetAppHandler(app_id)->OnMessage(app_id, message);
+      return;
+    case GCMEncryptionProvider::DECRYPTION_RESULT_INVALID_ENCRYPTION_HEADER:
+    case GCMEncryptionProvider::DECRYPTION_RESULT_INVALID_CRYPTO_KEY_HEADER:
+    case GCMEncryptionProvider::DECRYPTION_RESULT_NO_KEYS:
+    case GCMEncryptionProvider::DECRYPTION_RESULT_INVALID_SHARED_SECRET:
+    case GCMEncryptionProvider::DECRYPTION_RESULT_INVALID_PAYLOAD:
+      RecordDecryptionFailure(app_id, result);
+      return;
   }
 
-  encryption_provider_.DecryptMessage(
-      app_id, message,
-      base::Bind(&GCMDriver::DispatchMessage,
-                 weak_ptr_factory_.GetWeakPtr(), app_id),
-      base::Bind(&GCMDriver::RecordDecryptionFailure,
-                 weak_ptr_factory_.GetWeakPtr(), app_id));
+  NOTREACHED();
 }
 
 void GCMDriver::RegisterAfterUnregister(
     const std::string& app_id,
     const std::vector<std::string>& normalized_sender_ids,
     const UnregisterCallback& unregister_callback,
     GCMClient::Result result) {
   // Invoke the original unregister callback.
   unregister_callback.Run(result);
 
   // Trigger the pending registration.
   DCHECK(register_callbacks_.find(app_id) != register_callbacks_.end());
   RegisterImpl(app_id, normalized_sender_ids);
 }
 
 }  // namespace gcm