Ignore: v4_update_protocol_manager: Basic implementation with TODOs

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/base64.h"
 #include "base/macros.h"
@@ skipping 91 matching lines @@
     const V4ProtocolConfig& config)
     : gethash_error_count_(0),
       gethash_back_off_mult_(1),
       next_gethash_time_(Time::FromDoubleT(0)),
       config_(config),
       request_context_getter_(request_context_getter),
       url_fetcher_id_(0) {
 }
 
 // static
-void V4GetHashProtocolManager::RecordGetHashResult(ResultType result_type) {
+void V4GetHashProtocolManager::RecordGetHashResult(
+    OperationResultType result_type) {
   UMA_HISTOGRAM_ENUMERATION("SafeBrowsing.GetV4HashResult", result_type,
-                            GET_HASH_RESULT_MAX);
+                            OPERATION_RESULT_TYPE_MAX);
 }
 
 V4GetHashProtocolManager::~V4GetHashProtocolManager() {
   // Delete in-progress SafeBrowsing requests.
   STLDeleteContainerPairFirstPointers(hash_requests_.begin(),
                                       hash_requests_.end());
   hash_requests_.clear();
 }
 
 std::string V4GetHashProtocolManager::GetHashRequest(
@@ skipping 116 matching lines @@
     const std::vector<PlatformType>& platforms,
     ThreatType threat_type,
     FullHashCallback callback) {
   DCHECK(CalledOnValidThread());
   // We need to wait the minimum waiting duration, and if we are in backoff,
   // we need to check if we're past the next allowed time. If we are, we can
   // proceed with the request. If not, we are required to return empty results
   // (i.e. treat the page as safe).
   if (Time::Now() <= next_gethash_time_) {
     if (gethash_error_count_) {
-      RecordGetHashResult(GET_HASH_BACKOFF_ERROR);
+      RecordGetHashResult(ORT_BACKOFF_ERROR);

[Nathan Parker, 2016/02/23 18:47:06]

What's ORT? An idea: You could make these a "class enum" and then use
OperationResultType::BACKOFF_ERROR

[vakh (use Gerrit instead), 2016/02/23 23:58:20]

Done.
ORT was short for OperationResultType. I gave it this obscure name so that it
doesn't collide with another enum in the namespace but putting it in a class is
a better idea.

     } else {
-      RecordGetHashResult(GET_HASH_MIN_WAIT_DURATION_ERROR);
+      RecordGetHashResult(ORT_MIN_WAIT_DURATION_ERROR);
     }
     std::vector<SBFullHashResult> full_hashes;
     callback.Run(full_hashes, base::TimeDelta());
     return;
   }
 
   std::string req_base64 = GetHashRequest(prefixes, platforms, threat_type);
   GURL gethash_url = GetHashUrl(req_base64);
 
   net::URLFetcher* fetcher =
@@ skipping 30 matching lines @@
 
   int response_code = source->GetResponseCode();
   net::URLRequestStatus status = source->GetStatus();
   V4ProtocolManagerUtil::RecordHttpResponseOrErrorCode(
       kUmaV4HashResponseMetricName, status, response_code);
 
   const FullHashCallback& callback = it->second;
   std::vector<SBFullHashResult> full_hashes;
   base::TimeDelta negative_cache_duration;
   if (status.is_success() && response_code == net::HTTP_OK) {
-    RecordGetHashResult(GET_HASH_STATUS_200);
+    RecordGetHashResult(ORT_STATUS_200);
     ResetGetHashErrors();
     std::string data;
     source->GetResponseAsString(&data);
     if (!ParseHashResponse(data, &full_hashes, &negative_cache_duration)) {
       full_hashes.clear();
-      RecordGetHashResult(GET_HASH_PARSE_ERROR);
+      RecordGetHashResult(ORT_PARSE_ERROR);
     }
   } else {
     HandleGetHashError(Time::Now());
 
     DVLOG(1) << "SafeBrowsing GetEncodedFullHashes request for: "
              << source->GetURL() << " failed with error: " << status.error()
              << " and response code: " << response_code;
 
     if (status.status() == net::URLRequestStatus::FAILED) {
-      RecordGetHashResult(GET_HASH_NETWORK_ERROR);
+      RecordGetHashResult(ORT_NETWORK_ERROR);
     } else {
-      RecordGetHashResult(GET_HASH_HTTP_ERROR);
+      RecordGetHashResult(ORT_HTTP_ERROR);
     }
   }
 
   // Invoke the callback with full_hashes, even if there was a parse error or
   // an error response code (in which case full_hashes will be empty). The
   // caller can't be blocked indefinitely.
   callback.Run(full_hashes, negative_cache_duration);
 
   hash_requests_.erase(it);
 }
 
 void V4GetHashProtocolManager::HandleGetHashError(const Time& now) {
   DCHECK(CalledOnValidThread());
   base::TimeDelta next = V4ProtocolManagerUtil::GetNextBackOffInterval(
       &gethash_error_count_, &gethash_back_off_mult_);
   next_gethash_time_ = now + next;
 }
 
 GURL V4GetHashProtocolManager::GetHashUrl(const std::string& req_base64) const {
   return V4ProtocolManagerUtil::GetRequestUrl(req_base64, "encodedFullHashes",
                                               config_);
 }
 
 
 }  // namespace safe_browsing