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"
 #include "chrome/browser/chrome_elf_init_win.h"
 #include "chrome_elf/blacklist/blacklist.h"
 #include "chrome_elf/chrome_elf_constants.h"
 #include "chrome_elf/dll_hash/dll_hash.h"
 #include "content/public/browser/browser_thread.h"
 #include "version.h"  // NOLINT
 
 const char kBrowserBlacklistTrialName[] = "BrowserBlacklist";
 const char kBrowserBlacklistTrialDisabledGroupName[] = "NoBlacklist";
 
+const DWORD kBeaconAttempts = 2;
+
 namespace {
 
 // How long to wait, in seconds, before reporting for the second (and last
 // time), what dlls were blocked from the browser process.
 const int kBlacklistReportingDelaySec = 600;
 
 // This enum is used to define the buckets for an enumerated UMA histogram.
 // Hence,
 //   (a) existing enumerated constants should never be deleted or reordered, and
 //   (b) new constants should only be appended in front of
@@ skipping 65 matching lines @@
   // Schedule another task to report all sucessful interceptions later.
   // This time delay should be long enough to catch any dlls that attempt to
   // inject after Chrome has started up.
   content::BrowserThread::PostDelayedTask(
       content::BrowserThread::UI,
       FROM_HERE,
       base::Bind(&ReportSuccessfulBlocks),
       base::TimeDelta::FromSeconds(kBlacklistReportingDelaySec));
 }
 
+void GetBlacklistFailedCount(DWORD* failed_count) {
+  base::win::RegKey key(HKEY_CURRENT_USER,
+                        blacklist::kRegistryBeaconPath,
+                        KEY_QUERY_VALUE | KEY_SET_VALUE);
+  bool count_exists = key.HasValue(blacklist::kBeaconFailedCount);
+  if (!count_exists)
+    key.WriteValue(blacklist::kBeaconFailedCount, static_cast<DWORD>(0));
+
+  key.ReadValueDW(blacklist::kBeaconFailedCount, failed_count);
+}
+
 void BrowserBlacklistBeaconSetup() {
   base::win::RegKey blacklist_registry_key(HKEY_CURRENT_USER,
                                            blacklist::kRegistryBeaconPath,
                                            KEY_QUERY_VALUE | KEY_SET_VALUE);
 
   // 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) {
     RecordBlacklistSetupEvent(BLACKLIST_SETUP_RAN_SUCCESSFULLY);
+
+    // The blacklist was enabled successfully so we record the event (along with
+    // the number of failed previous attempts) and reset the failure count.
+    DWORD failed_attempt_count = 0;
+    GetBlacklistFailedCount(&failed_attempt_count);
+    UMA_HISTOGRAM_COUNTS("Blacklist.RetryWorked", failed_attempt_count);
+
+    blacklist_registry_key.WriteValue(blacklist::kBeaconFailedCount,
+                                      static_cast<DWORD>(0));
+
   } 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.
+    // Some part of the blacklist failed.  If this has occured some minimum
+    // number of times in a row we give up, disable it, and record the
+    // disabling event with UMA.
     if (blacklist_state != blacklist::BLACKLIST_DISABLED) {
-      blacklist_registry_key.WriteValue(blacklist::kBeaconState,
-                                        blacklist::BLACKLIST_DISABLED);
+      DWORD failed_attempt_count = 0;
+      GetBlacklistFailedCount(&failed_attempt_count);
+      failed_attempt_count = failed_attempt_count + 1;
+
+      if (failed_attempt_count >= kBeaconAttempts) {
+        blacklist_registry_key.WriteValue(blacklist::kBeaconState,
+                                          blacklist::BLACKLIST_DISABLED);
+        UMA_HISTOGRAM_COUNTS("Blacklist.Disabled", true);
+      } else {
+        blacklist_registry_key.WriteValue(blacklist::kBeaconFailedCount,
+                                          failed_attempt_count);
+        blacklist_registry_key.WriteValue(blacklist::kBeaconState,
+                                          blacklist::BLACKLIST_ENABLED);
+      }
     }
   }
 
   // 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::kBeaconFailedCount,
+                                      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);
   }
 }