Consolidate some safe-browsing histograms.

chrome/browser/safe_browsing/safe_browsing_service.cc

 // Copyright (c) 2010 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/safe_browsing/safe_browsing_service.h"
 
 #include "base/callback.h"
 #include "base/command_line.h"
 #include "base/lazy_instance.h"
 #include "base/path_service.h"
@@ skipping 17 matching lines @@
 #include "chrome/common/url_constants.h"
 #include "net/base/registry_controlled_domain.h"
 
 #if defined(OS_WIN)
 #include "chrome/installer/util/browser_distribution.h"
 #endif
 
 using base::Time;
 using base::TimeDelta;
 
+namespace {
+
 // The default URL prefix where browser fetches chunk updates, hashes,
 // and reports safe browsing hits.
-static const char* const kSbDefaultInfoURLPrefix =
+const char* const kSbDefaultInfoURLPrefix =
     "http://safebrowsing.clients.google.com/safebrowsing";
 
 // The default URL prefix where browser fetches MAC client key and reports
 // malware details.
-static const char* const kSbDefaultMacKeyURLPrefix =
+const char* const kSbDefaultMacKeyURLPrefix =
     "https://sb-ssl.google.com/safebrowsing";
 
-static Profile* GetDefaultProfile() {
+Profile* GetDefaultProfile() {
   FilePath user_data_dir;
   PathService::Get(chrome::DIR_USER_DATA, &user_data_dir);
   ProfileManager* profile_manager = g_browser_process->profile_manager();
   return profile_manager->GetDefaultProfile(user_data_dir);
 }
 
+// The full calls are kind of long...
+void RecordGetHashFullHashEmpty() {
+  SafeBrowsingProtocolManager::RecordGetHashResult(
+      SafeBrowsingProtocolManager::GET_HASH_FULL_HASH_EMPTY);
+}
+void RecordGetHashFullHashHit() {
+  SafeBrowsingProtocolManager::RecordGetHashResult(
+      SafeBrowsingProtocolManager::GET_HASH_FULL_HASH_HIT);
+}
+
+}  // namespace
+
 // static
 SafeBrowsingServiceFactory* SafeBrowsingService::factory_ = NULL;
 
 // The default SafeBrowsingServiceFactory.  Global, made a singleton so we
 // don't leak it.
 class SafeBrowsingServiceFactoryImpl : public SafeBrowsingServiceFactory {
  public:
   virtual SafeBrowsingService* CreateSafeBrowsingService() {
     return new SafeBrowsingService();
   }
@@ skipping 566 matching lines @@
       GetHashRequestors requestors;
       requestors.push_back(check);
       gethash_requests_[prefix] = requestors;
     }
 
     // Reset the start time so that we can measure the network time without the
     // database time.
     check->start = Time::Now();
     protocol_manager_->GetFullHash(check, check->prefix_hits);
   } else {
-    // We may have cached results for previous GetHash queries.
+    // We may have cached results for previous GetHash queries.  Since
+    // this data comes from cache, don't histogram hits.
     HandleOneCheck(check, check->full_hits);
   }
 }
 
 void SafeBrowsingService::GetAllChunksFromDatabase() {
   DCHECK_EQ(MessageLoop::current(), safe_browsing_thread_->message_loop());
 
   bool database_error = true;
   std::vector<SBListChunkRanges> lists;
   DCHECK(!database_update_in_progress_);
@@ skipping 153 matching lines @@
 void SafeBrowsingService::CacheHashResults(
   const std::vector<SBPrefix>& prefixes,
   const std::vector<SBFullHashResult>& full_hashes) {
   DCHECK_EQ(MessageLoop::current(), safe_browsing_thread_->message_loop());
   GetDatabase()->CacheHashResults(prefixes, full_hashes);
 }
 
 void SafeBrowsingService::OnHandleGetHashResults(
     SafeBrowsingCheck* check,
     const std::vector<SBFullHashResult>& full_hashes) {
+  if (full_hashes.empty())
+    RecordGetHashFullHashEmpty();
+
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
   SBPrefix prefix = check->prefix_hits[0];
   GetHashRequests::iterator it = gethash_requests_.find(prefix);
   if (check->prefix_hits.size() > 1 || it == gethash_requests_.end()) {
-    HandleOneCheck(check, full_hashes);
+    if (HandleOneCheck(check, full_hashes))
+      RecordGetHashFullHashHit();
     return;
   }
 
-  // Call back all interested parties.
+  // Call back all interested parties, noting if any has a hit.
   GetHashRequestors& requestors = it->second;
+  bool hit = false;
   for (GetHashRequestors::iterator r = requestors.begin();
        r != requestors.end(); ++r) {
-    HandleOneCheck(*r, full_hashes);
+    if (HandleOneCheck(*r, full_hashes))
+      hit = true;
   }
 
+  // Record that a hit was seen.
+  if (hit)
+    RecordGetHashFullHashHit();
+
   gethash_requests_.erase(it);
 }
 
-void SafeBrowsingService::HandleOneCheck(
+bool SafeBrowsingService::HandleOneCheck(
     SafeBrowsingCheck* check,
     const std::vector<SBFullHashResult>& full_hashes) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
+
+  // Always calculate the index for recording hits.
+  int index = safe_browsing_util::CompareFullHashes(check->url, full_hashes);
+
+  // |client| is NULL if the request was cancelled.
   if (check->client) {
     UrlCheckResult result = URL_SAFE;
-    int index = safe_browsing_util::CompareFullHashes(check->url, full_hashes);
-    if (index != -1) {
+    if (index != -1)
       result = GetResultFromListname(full_hashes[index].list_name);
-    } else {
-      // Log the case where the SafeBrowsing servers return full hashes in the
-      // GetHash response that match the prefix we're looking up, but don't
-      // match the full hash of the URL.
-      if (!full_hashes.empty())
-        UMA_HISTOGRAM_COUNTS("SB2.GetHashServerMiss", 1);
-    }
 
     // Let the client continue handling the original request.
     check->client->OnSafeBrowsingResult(check->url, result);
   }
 
   checks_.erase(check);
   delete check;
+
+  return (index != -1);
 }
 
 void SafeBrowsingService::DoDisplayBlockingPage(
     const UnsafeResource& resource) {
   // The tab might have been closed.
   TabContents* wc =
       tab_util::GetTabContentsByID(resource.render_process_host_id,
                                    resource.render_view_id);
 
   if (!wc) {
@@ skipping 75 matching lines @@
 // checkbox on the blocking page.
 void SafeBrowsingService::ReportMalwareDetails(
     scoped_refptr<MalwareDetails> details) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
   scoped_ptr<const std::string> serialized(details->GetSerializedReport());
   if (!serialized->empty()) {
     DVLOG(1) << "Sending serialized malware details.";
     protocol_manager_->ReportMalwareDetails(*serialized);
   }
 }