Add some histograms to see how often users click through blocking pages....

chrome/browser/safe_browsing/safe_browsing_blocking_page.cc

 // Copyright (c) 2006-2008 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.
 //
 // Implementation of the SafeBrowsingBlockingPage class.
 
 #include "chrome/browser/safe_browsing/safe_browsing_blocking_page.h"
 
+#include "base/histogram.h"
 #include "base/string_util.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/dom_operation_notification_details.h"
 #include "chrome/browser/dom_ui/new_tab_ui.h"
 #include "chrome/browser/google_util.h"
 #include "chrome/browser/safe_browsing/safe_browsing_service.h"
 #include "chrome/browser/tab_contents/navigation_controller.h"
 #include "chrome/browser/tab_contents/navigation_entry.h"
 #include "chrome/browser/tab_contents/tab_util.h"
 #include "chrome/browser/tab_contents/web_contents.h"
@@ skipping 23 matching lines @@
     L"<a href=\"\" onClick=\"sendCommand('showDiagnostic'); return false;\" "
     L"onMouseDown=\"return false;\">%ls</a>";
 
 // The commands returned by the page when the user performs an action.
 static const char* const kShowDiagnosticCommand = "showDiagnostic";
 static const char* const kReportErrorCommand = "reportError";
 static const char* const kLearnMoreCommand = "learnMore";
 static const char* const kProceedCommand = "proceed";
 static const char* const kTakeMeBackCommand = "takeMeBack";
 
+namespace {
+
+enum SafeBrowsingBlockingPageEvent {
+  SHOW,
+  PROCEED,
+  DONT_PROCEED,
+};
+
+void RecordSafeBrowsingBlockingPageStats(SafeBrowsingBlockingPageEvent event) {
+  static LinearHistogram histogram("interstial.safe_browsing", 0, 2, 4);

[jar (doing other things), 2009/04/27 00:20:49]

Looking at the unit test, and other examples, the more common set of numbers
(for min, max, count) would be:

1, N, N+1

In this case, perchance:

1, 3, 4 would be best.

Also note, that it is good to leave one additional bucket unused, as buckets are
defined as having a min and max value.  Hence the "top bucket" is always "N no
infinity".  This can cause problems if you later decide to add another bucket,
and then you have a distinct "N to N+1" and "N to infinity" coming from
different flavors of the histogram.

+  histogram.SetFlags(kUmaTargetedHistogramFlag);
+  histogram.Add(event);
+}
+
+}  // namespace
 // static
 SafeBrowsingBlockingPageFactory* SafeBrowsingBlockingPage::factory_ = NULL;
 
 // The default SafeBrowsingBlockingPageFactory.  Global, made a singleton so we
 // don't leak it.
 class SafeBrowsingBlockingPageFactoryImpl
     : public SafeBrowsingBlockingPageFactory {
  public:
   SafeBrowsingBlockingPage* CreateSafeBrowsingPage(
       SafeBrowsingService* service,
@@ skipping 14 matching lines @@
 SafeBrowsingBlockingPage::SafeBrowsingBlockingPage(
     SafeBrowsingService* sb_service,
     WebContents* web_contents,
     const UnsafeResourceList& unsafe_resources)
     : InterstitialPage(web_contents,
                        IsMainPage(unsafe_resources),
                        unsafe_resources[0].url),
       sb_service_(sb_service),
       is_main_frame_(IsMainPage(unsafe_resources)),
       unsafe_resources_(unsafe_resources) {
+  RecordSafeBrowsingBlockingPageStats(SHOW);
   if (!is_main_frame_) {
     navigation_entry_index_to_remove_ =
         tab()->controller().last_committed_entry_index();
   } else {
     navigation_entry_index_to_remove_ = -1;
   }
 }
 
 SafeBrowsingBlockingPage::~SafeBrowsingBlockingPage() {
 }
@@ skipping 259 matching lines @@
     DCHECK(unsafe_resources_[element_index].threat_type ==
            SafeBrowsingService::URL_MALWARE);
     tab()->OpenURL(diagnostic_url, GURL(), CURRENT_TAB, PageTransition::LINK);
     return;
   }
 
   NOTREACHED() << "Unexpected command: " << command;
 }
 
 void SafeBrowsingBlockingPage::Proceed() {
+  RecordSafeBrowsingBlockingPageStats(PROCEED);
+
   NotifySafeBrowsingService(sb_service_, unsafe_resources_, true);
 
   // Check to see if some new notifications of unsafe resources have been
   // received while we were showing the interstitial.
   UnsafeResourceMap* unsafe_resource_map = GetUnsafeResourcesMap();
   UnsafeResourceMap::iterator iter = unsafe_resource_map->find(tab());
   SafeBrowsingBlockingPage* blocking_page = NULL;
   if (iter != unsafe_resource_map->end() && !iter->second.empty()) {
     // Build an interstitial for all the unsafe resources notifications.
     // Don't show it now as showing an interstitial while an interstitial is
     // already showing would cause DontProceed() to be invoked.
     blocking_page = factory_->CreateSafeBrowsingPage(sb_service_, tab(),
                                                      iter->second);
     unsafe_resource_map->erase(iter);
   }
 
   InterstitialPage::Proceed();
   // We are now deleted.
 
   // Now that this interstitial is gone, we can show the new one.
   if (blocking_page)
     blocking_page->Show();
 }
 
 void SafeBrowsingBlockingPage::DontProceed() {
+  RecordSafeBrowsingBlockingPageStats(DONT_PROCEED);
+
   NotifySafeBrowsingService(sb_service_, unsafe_resources_, false);
 
   // The user does not want to proceed, clear the queued unsafe resources
   // notifications we received while the interstitial was showing.
   UnsafeResourceMap* unsafe_resource_map = GetUnsafeResourcesMap();
   UnsafeResourceMap::iterator iter = unsafe_resource_map->find(tab());
   if (iter != unsafe_resource_map->end() && !iter->second.empty()) {
     NotifySafeBrowsingService(sb_service_, iter->second, false);
     unsafe_resource_map->erase(iter);
   }
@@ skipping 60 matching lines @@
   UnsafeResourceMap* unsafe_resource_map = GetUnsafeResourcesMap();
   (*unsafe_resource_map)[web_contents].push_back(unsafe_resource);
 }
 
 // static
 bool SafeBrowsingBlockingPage::IsMainPage(
     const UnsafeResourceList& unsafe_resources) {
   return unsafe_resources.size() == 1 &&
          unsafe_resources[0].resource_type == ResourceType::MAIN_FRAME;
 }