Adding metrics for Instant URL blacklist events.

chrome/browser/instant/instant_controller.cc

 // Copyright 2012 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/instant/instant_controller.h"
 
 #include "base/command_line.h"
 #include "base/metrics/histogram.h"
 #include "base/string_util.h"
 #include "base/utf_string_conversions.h"
@@ skipping 30 matching lines @@
 const int kUpdateBoundsDelayMS = 1000;
 
 // The maximum number of times we'll load a non-Instant-supporting search engine
 // before we give up and blacklist it for the rest of the browsing session.
 const int kMaxInstantSupportFailures = 10;
 
 // If an Instant page has not been used in these many milliseconds, it is
 // reloaded so that the page does not become stale.
 const int kStaleLoaderTimeoutMS = 3 * 3600 * 1000;
 
+// For reporting events of interest.
+enum InstantControllerEvent {
+  INSTANT_CONTROLLER_EVENT_URL_ADDED_TO_BLACKLIST = 0,
+  INSTANT_CONTROLLER_EVENT_URL_REMOVED_FROM_BLACKLIST = 1,
+  INSTANT_CONTROLLER_EVENT_URL_BLOCKED_BY_BLACKLIST = 2,
+  INSTANT_CONTROLLER_EVENT_MAX = 3,
+};
+
+void RecordEventHistogram(InstantControllerEvent event) {
+  UMA_HISTOGRAM_ENUMERATION("Instant.InstantControllerEvent",
+                            event,
+                            INSTANT_CONTROLLER_EVENT_MAX);
+}
+
 void AddSessionStorageHistogram(bool extended_enabled,
                                 const content::WebContents* tab1,
                                 const content::WebContents* tab2) {
   base::Histogram* histogram = base::BooleanHistogram::FactoryGet(
       std::string("Instant.SessionStorageNamespace") +
           (extended_enabled ? "_Extended" : "_Instant"),
       base::Histogram::kUmaTargetedHistogramFlag);
   const content::SessionStorageNamespaceMap& session_storage_map1 =
       tab1->GetController().GetSessionStorageNamespaceMap();
   const content::SessionStorageNamespaceMap& session_storage_map2 =
@@ skipping 743 matching lines @@
     const content::WebContents* contents,
     bool supports_instant) {
   if (instant_tab_ && instant_tab_->contents() == contents) {
     if (!supports_instant)
       MessageLoop::current()->DeleteSoon(FROM_HERE, instant_tab_.release());
     return;
   }
 
   if (loader_ && loader_->contents() == contents) {
     if (supports_instant) {
-      blacklisted_urls_.erase(loader_->instant_url());
+      if (blacklisted_urls_.erase(loader_->instant_url())) {
+        RecordEventHistogram(
+            INSTANT_CONTROLLER_EVENT_URL_REMOVED_FROM_BLACKLIST);
+      }
     } else {
       ++blacklisted_urls_[loader_->instant_url()];
+      RecordEventHistogram(INSTANT_CONTROLLER_EVENT_URL_ADDED_TO_BLACKLIST);
       HideInternal();
       delete loader_->ReleaseContents();
       MessageLoop::current()->DeleteSoon(FROM_HERE, loader_.release());
       CreateDefaultLoader();
     }
     content::NotificationService::current()->Notify(
         chrome::NOTIFICATION_INSTANT_SUPPORT_DETERMINED,
         content::Source<InstantController>(this),
         content::NotificationService::NoDetails());
   }
@@ skipping 367 matching lines @@
       if (!url_obj.is_valid())
         return false;
 
       *instant_url = url_obj.spec();
     }
   }
 
   std::map<std::string, int>::const_iterator iter =
       blacklisted_urls_.find(*instant_url);
   if (iter != blacklisted_urls_.end() &&
-      iter->second > kMaxInstantSupportFailures)
+      iter->second > kMaxInstantSupportFailures) {
+    RecordEventHistogram(INSTANT_CONTROLLER_EVENT_URL_BLOCKED_BY_BLACKLIST);
     return false;
+  }
 
   return true;
 }