Change default mode of extension install verification

chrome/browser/extensions/install_signer.cc

 // Copyright 2013 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 "chrome/browser/extensions/install_signer.h"
 
 #include "base/base64.h"
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/json/json_reader.h"
 #include "base/json/json_writer.h"
+#include "base/lazy_instance.h"
 #include "base/message_loop/message_loop.h"
 #include "base/metrics/histogram.h"
+#include "base/process/process_info.h"
 #include "base/stl_util.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_split.h"
 #include "base/strings/string_util.h"
 #include "base/strings/stringprintf.h"
+#include "base/time/time.h"
 #include "base/values.h"
 #include "chrome/common/chrome_switches.h"
 #include "chrome/common/extensions/extension_constants.h"
 #include "crypto/random.h"
 #include "crypto/secure_hash.h"
 #include "crypto/sha2.h"
 #include "crypto/signature_verifier.h"
 #include "net/url_request/url_fetcher.h"
 #include "net/url_request/url_fetcher_delegate.h"
 #include "net/url_request/url_request_context_getter.h"
@@ skipping 207 matching lines @@
   std::string value = CommandLine::ForCurrentProcess()->GetSwitchValueASCII(
       switches::kExtensionsNotWebstore);
   if (value.empty())
     return ExtensionIdSet();
 
   std::vector<std::string> ids;
   base::SplitString(value, ',', &ids);
   return ExtensionIdSet(ids.begin(), ids.end());
 }
 
+namespace {
+
+static int g_request_count = 0;
+
+base::LazyInstance<base::TimeTicks> g_last_request_time =
+    LAZY_INSTANCE_INITIALIZER;
+
+base::LazyInstance<base::ThreadChecker> g_single_thread_checker =
+    LAZY_INSTANCE_INITIALIZER;
+
+void LogRequestStartHistograms() {
+  // Make sure we only ever call this from one thread, so that we don't have to
+  // worry about race conditions setting g_last_request_time.
+  DCHECK(g_single_thread_checker.Get().CalledOnValidThread());
+
+  const base::Time process_creation_time =
+      base::CurrentProcessInfo::CreationTime();
+  UMA_HISTOGRAM_COUNTS("ExtensionInstallSigner.UptimeAtTimeOfRequest",
+                       (base::Time::Now() - process_creation_time).InSeconds());
+
+  base::TimeDelta delta;
+  base::TimeTicks now = base::TimeTicks::Now();
+  if (!g_last_request_time.Get().is_null())
+    delta = now - g_last_request_time.Get();
+  g_last_request_time.Get() = now;
+  UMA_HISTOGRAM_COUNTS("ExtensionInstallSigner.SecondsSinceLastRequest",
+                       delta.InSeconds());
+
+  g_request_count += 1;
+  UMA_HISTOGRAM_COUNTS_100("ExtensionInstallSigner.RequestCount",
+                           g_request_count);
+}
+
+}  // namespace
+
 void InstallSigner::GetSignature(const SignatureCallback& callback) {
   CHECK(!url_fetcher_.get());
   CHECK(callback_.is_null());
   CHECK(salt_.empty());
   callback_ = callback;
 
   // If the set of ids is empty, just return an empty signature and skip the
   // call to the server.
   if (ids_.empty()) {
     if (!callback_.is_null())
@@ skipping 38 matching lines @@
     id_list->AppendString(*i);
   }
   dictionary.Set(kIdsKey, id_list.release());
   std::string json;
   base::JSONWriter::Write(&dictionary, &json);
   if (json.empty()) {
     ReportErrorViaCallback();
     return;
   }
   url_fetcher_->SetUploadData("application/json", json);
+  LogRequestStartHistograms();
   url_fetcher_->Start();
 }
 
 void InstallSigner::ReportErrorViaCallback() {
   InstallSignature* null_signature = NULL;
   if (!callback_.is_null())
     callback_.Run(scoped_ptr<InstallSignature>(null_signature));
 }
 
 void InstallSigner::ParseFetchResponse() {
+  bool fetch_success = url_fetcher_->GetStatus().is_success();
+  UMA_HISTOGRAM_BOOLEAN("ExtensionInstallSigner.FetchSuccess", fetch_success);
+
   std::string response;
-  if (!url_fetcher_->GetStatus().is_success() ||
-      !url_fetcher_->GetResponseAsString(&response) ||
-      response.empty()) {
+  if (fetch_success) {
+    if (!url_fetcher_->GetResponseAsString(&response))
+      response.clear();
+  }
+  UMA_HISTOGRAM_BOOLEAN("ExtensionInstallSigner.GetResponseSuccess",
+                        !response.empty());
+  if (!fetch_success || response.empty()) {
     ReportErrorViaCallback();
     return;
   }
 
   // The response is JSON of the form:
   // {
   //   "protocol_version": "1",
   //   "signature": "<base64-encoded signature>",
   //   "expiry": "<date in YYYY-MM-DD form>",
   //   "invalid_ids": [ "<id3>", "<id4>" ]
   // }
   // where |invalid_ids| is a list of ids from the original request that
   // could not be verified to be in the webstore.
 
   base::DictionaryValue* dictionary = NULL;
   scoped_ptr<base::Value> parsed(base::JSONReader::Read(response));
-  if (!parsed.get() || !parsed->GetAsDictionary(&dictionary)) {
+  bool json_success = parsed.get() && parsed->GetAsDictionary(&dictionary);
+  UMA_HISTOGRAM_BOOLEAN("ExtensionInstallSigner.ParseJsonSuccess",
+                        json_success);
+  if (!json_success) {
     ReportErrorViaCallback();
     return;
   }
 
   int protocol_version = 0;
   std::string signature_base64;
   std::string signature;
   std::string expire_date;
 
   dictionary->GetInteger(kProtocolVersionKey, &protocol_version);
   dictionary->GetString(kSignatureKey, &signature_base64);
   dictionary->GetString(kExpiryKey, &expire_date);
 
-  if (protocol_version != 1 || signature_base64.empty() ||
-      !ValidateExpireDateFormat(expire_date) ||
-      !base::Base64Decode(signature_base64, &signature)) {
+  bool fields_success =
+      protocol_version == 1 && !signature_base64.empty() &&
+      ValidateExpireDateFormat(expire_date) &&
+      base::Base64Decode(signature_base64, &signature);
+  UMA_HISTOGRAM_BOOLEAN("ExtensionInstallSigner.ParseFieldsSuccess",
+                        fields_success);
+  if (!fields_success) {
     ReportErrorViaCallback();
     return;
   }
 
   ExtensionIdSet invalid_ids;
   const base::ListValue* invalid_ids_list = NULL;
   if (dictionary->GetList(kInvalidIdsKey, &invalid_ids_list)) {
     for (size_t i = 0; i < invalid_ids_list->GetSize(); i++) {
       std::string id;
       if (!invalid_ids_list->GetString(i, &id)) {
@@ skipping 27 matching lines @@
     if (!verified)
       result.reset();
   }
 
   if (!callback_.is_null())
     callback_.Run(result.Pass());
 }
 
 
 }  // namespace extensions