PVer4: Add UMA metrics for time taken to: load DB, do prefix check,

components/safe_browsing_db/v4_get_hash_protocol_manager.cc

 // Copyright 2016 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 "components/safe_browsing_db/v4_get_hash_protocol_manager.h"
 
 #include <utility>
 
 #include "base/base64url.h"
 #include "base/macros.h"
@@ skipping 153 matching lines @@
 // ----------------------------------------------------------------
 
 FullHashCallbackInfo::FullHashCallbackInfo() {}
 
 FullHashCallbackInfo::FullHashCallbackInfo(
     const std::vector<FullHashInfo>& cached_full_hash_infos,
     const std::vector<HashPrefix>& prefixes_requested,
     std::unique_ptr<net::URLFetcher> fetcher,
     const FullHashToStoreAndHashPrefixesMap&
         full_hash_to_store_and_hash_prefixes,
-    const FullHashCallback& callback)
+    const FullHashCallback& callback,
+    const base::Time& network_start_time)
     : cached_full_hash_infos(cached_full_hash_infos),
       callback(callback),
       fetcher(std::move(fetcher)),
       full_hash_to_store_and_hash_prefixes(
           full_hash_to_store_and_hash_prefixes),
+      network_start_time(network_start_time),
       prefixes_requested(prefixes_requested) {}
 
 FullHashCallbackInfo::~FullHashCallbackInfo() {}
 
 // ----------------------------------------------------------------
 
 FullHashInfo::FullHashInfo(const FullHash& full_hash,
                            const ListIdentifier& list_id,
                            const base::Time& positive_expiry)
     : full_hash(full_hash),
@@ skipping 101 matching lines @@
   std::string req_base64 = GetHashRequest(prefixes_to_request);
   GURL gethash_url;
   net::HttpRequestHeaders headers;
   GetHashUrlAndHeaders(req_base64, &gethash_url, &headers);
 
   std::unique_ptr<net::URLFetcher> owned_fetcher = net::URLFetcher::Create(
       url_fetcher_id_++, gethash_url, net::URLFetcher::GET, this);
   net::URLFetcher* fetcher = owned_fetcher.get();
   pending_hash_requests_[fetcher].reset(new FullHashCallbackInfo(
       cached_full_hash_infos, prefixes_to_request, std::move(owned_fetcher),
-      full_hash_to_store_and_hash_prefixes, callback));
+      full_hash_to_store_and_hash_prefixes, callback, clock_->Now()));
 
   fetcher->SetExtraRequestHeaders(headers.ToString());
   fetcher->SetLoadFlags(net::LOAD_DISABLE_CACHE);
   fetcher->SetRequestContext(request_context_getter_.get());
   fetcher->Start();
 }
 
 void V4GetHashProtocolManager::GetFullHashesWithApis(
     const GURL& url,
     ThreatMetadataForApiCallback api_callback) {
@@ skipping 407 matching lines @@
              << " and response code: " << response_code;
 
     if (status.status() == net::URLRequestStatus::FAILED) {
       RecordGetHashResult(V4OperationResult::NETWORK_ERROR);
     } else {
       RecordGetHashResult(V4OperationResult::HTTP_ERROR);
     }
   }
 
   const std::unique_ptr<FullHashCallbackInfo>& fhci = it->second;
+  UMA_HISTOGRAM_LONG_TIMES("SafeBrowsing.V4GetHashNetwork.Time",
+                           clock_->Now() - fhci->network_start_time);
   UpdateCache(fhci->prefixes_requested, full_hash_infos, negative_cache_expire);
   MergeResults(fhci->full_hash_to_store_and_hash_prefixes, full_hash_infos,
                &fhci->cached_full_hash_infos);
 
   fhci->callback.Run(fhci->cached_full_hash_infos);
 
   pending_hash_requests_.erase(it);
 }
 
 #ifndef DEBUG
 std::ostream& operator<<(std::ostream& os, const FullHashInfo& fhi) {
   os << "{full_hash: " << fhi.full_hash << "; list_id: " << fhi.list_id
      << "; positive_expiry: " << fhi.positive_expiry
      << "; metadata.api_permissions.size(): "
      << fhi.metadata.api_permissions.size() << "}";
   return os;
 }
 #endif
 
 }  // namespace safe_browsing