Can now adjust the number of retries before the blacklist is disabled.

chrome/browser/chrome_elf_init_win.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 "base/bind.h"
 #include "base/metrics/field_trial.h"
 #include "base/metrics/histogram.h"
 #include "base/metrics/sparse_histogram.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/win/registry.h"
@@ skipping 22 matching lines @@
 enum BlacklistSetupEventType {
   // The blacklist beacon has placed to enable the browser blacklisting.
   BLACKLIST_SETUP_ENABLED = 0,
 
   // The blacklist was successfully enabled.
   BLACKLIST_SETUP_RAN_SUCCESSFULLY,
 
   // The blacklist setup code failed to execute.
   BLACKLIST_SETUP_FAILED,
 
-  // The blacklist thunk setup code failed to execute.
+  // Deprecated. The blacklist thunk setup code failed to execute.

[robertshield, 2014/06/16 13:56:54]

Mention in the CL description that these are being deprecated and why it is ok
to do so. 

[krstnmnlsn, 2014/06/16 17:37:43]

Done.

   BLACKLIST_THUNK_SETUP_FAILED,
 
-  // The blacklist interception code failed to execute.
+  // Deprecated. The blacklist interception code failed to execute.
   BLACKLIST_INTERCEPTION_FAILED,
 
+  // The blacklist was disabled for this run (after it failed too many times).
+  BLACKLIST_SETUP_DISABLED,
+
   // Always keep this at the end.
   BLACKLIST_SETUP_EVENT_MAX,
 };
 
 void RecordBlacklistSetupEvent(BlacklistSetupEventType blacklist_setup_event) {
   UMA_HISTOGRAM_ENUMERATION("Blacklist.Setup",
                             blacklist_setup_event,
                             BLACKLIST_SETUP_EVENT_MAX);
 }
 
@@ skipping 74 matching lines @@
 
   // No point in trying to continue if the registry key isn't valid.
   if (!blacklist_registry_key.Valid())
     return;
 
   // Record the results of the last blacklist setup.
   DWORD blacklist_state = blacklist::BLACKLIST_STATE_MAX;
   blacklist_registry_key.ReadValueDW(blacklist::kBeaconState, &blacklist_state);
 
   if (blacklist_state == blacklist::BLACKLIST_ENABLED) {
+    // The blacklist was enabled successfully so we record the event (along with
+    // the number of failed previous attempts).
     RecordBlacklistSetupEvent(BLACKLIST_SETUP_RAN_SUCCESSFULLY);
-  } else {
-    switch (blacklist_state) {
-      case blacklist::BLACKLIST_SETUP_RUNNING:
-        RecordBlacklistSetupEvent(BLACKLIST_SETUP_FAILED);
-        break;
-      case blacklist::BLACKLIST_THUNK_SETUP:
-        RecordBlacklistSetupEvent(BLACKLIST_THUNK_SETUP_FAILED);
-        break;
-      case blacklist::BLACKLIST_INTERCEPTING:
-        RecordBlacklistSetupEvent(BLACKLIST_INTERCEPTION_FAILED);
-        break;
-    }
-
-    // Since some part of the blacklist failed, mark it as disabled
-    // for this version.
-    if (blacklist_state != blacklist::BLACKLIST_DISABLED) {
-      blacklist_registry_key.WriteValue(blacklist::kBeaconState,
-                                        blacklist::BLACKLIST_DISABLED);
-    }
+    DWORD attempt_count = 0;
+    blacklist_registry_key.ReadValueDW(blacklist::kBeaconAttemptCount,
+                                       &attempt_count);
+    UMA_HISTOGRAM_COUNTS_100("Blacklist.RetryAttempts.Success", attempt_count);
+  } else if (blacklist_state == blacklist::BLACKLIST_SETUP_FAILED) {
+    // We can set the state to disabled without checking that the maximum number
+    // of attempts was exceeded because blacklist.cc has already done this.
+    RecordBlacklistSetupEvent(BLACKLIST_SETUP_FAILED);
+    blacklist_registry_key.WriteValue(blacklist::kBeaconState,
+                                      blacklist::BLACKLIST_DISABLED);
+  } else if (blacklist_state == blacklist::BLACKLIST_DISABLED) {
+    RecordBlacklistSetupEvent(BLACKLIST_SETUP_DISABLED);
   }
 
   // Find the last recorded blacklist version.
   base::string16 blacklist_version;
   blacklist_registry_key.ReadValue(blacklist::kBeaconVersion,
                                    &blacklist_version);
 
   if (blacklist_version != TEXT(CHROME_VERSION_STRING)) {
-    // The blacklist hasn't been enabled for this version yet, so enable it.
+    // The blacklist hasn't been enabled for this version yet, so enable it
+    // and reset the failure count to zero.
     LONG set_version = blacklist_registry_key.WriteValue(
         blacklist::kBeaconVersion,
         TEXT(CHROME_VERSION_STRING));
 
     LONG set_state = blacklist_registry_key.WriteValue(
         blacklist::kBeaconState,
         blacklist::BLACKLIST_ENABLED);
 
+    blacklist_registry_key.WriteValue(blacklist::kBeaconAttemptCount,
+                                      static_cast<DWORD>(0));
+
     // Only report the blacklist as getting setup when both registry writes
     // succeed, since otherwise the blacklist wasn't properly setup.
     if (set_version == ERROR_SUCCESS && set_state == ERROR_SUCCESS)
       RecordBlacklistSetupEvent(BLACKLIST_SETUP_ENABLED);
   }
 }