Move code in components/safe_browsing_db and chrome/browser/s_b/ under the safe_browsing namespace.

chrome/browser/safe_browsing/protocol_manager.cc

 // Copyright (c) 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/safe_browsing/protocol_manager.h"
 
 #include "base/environment.h"
 #include "base/logging.h"
 #include "base/memory/scoped_vector.h"
 #include "base/metrics/histogram_macros.h"
@@ skipping 15 matching lines @@
 #include "net/base/net_errors.h"
 #include "net/http/http_response_headers.h"
 #include "net/http/http_status_code.h"
 #include "net/url_request/url_fetcher.h"
 #include "net/url_request/url_request_context_getter.h"
 #include "net/url_request/url_request_status.h"
 
 using base::Time;
 using base::TimeDelta;
 
-namespace {
+namespace safe_browsing {
 
 // UpdateResult indicates what happened with the primary and/or backup update
 // requests. The ordering of the values must stay the same for UMA consistency,
 // and is also ordered in this way to match ProtocolManager::BackupUpdateReason.
 enum UpdateResult {
   UPDATE_RESULT_FAIL,
   UPDATE_RESULT_SUCCESS,
   UPDATE_RESULT_BACKUP_CONNECT_FAIL,
   UPDATE_RESULT_BACKUP_CONNECT_SUCCESS,
   UPDATE_RESULT_BACKUP_HTTP_FAIL,
@@ skipping 18 matching lines @@
 base::TimeDelta GetNextUpdateIntervalFromFinch() {
   std::string num_str = variations::GetVariationParamValue(
       kSBUpdateFrequencyFinchExperiment, kSBUpdateFrequencyFinchParam);
   int finch_next_update_interval_minutes = 0;
   if (!base::StringToInt(num_str, &finch_next_update_interval_minutes)) {
     finch_next_update_interval_minutes = 0;  // Defaults to 0.
   }
   return base::TimeDelta::FromMinutes(finch_next_update_interval_minutes);
 }
 
-}  // namespace
-
 // Minimum time, in seconds, from start up before we must issue an update query.
 static const int kSbTimerStartIntervalSecMin = 60;
 
 // Maximum time, in seconds, from start up before we must issue an update query.
 static const int kSbTimerStartIntervalSecMax = 300;
 
 // The maximum time, in seconds, to wait for a response to an update request.
 static const int kSbMaxUpdateWaitSec = 30;
 
 // Maximum back off multiplier.
 static const size_t kSbMaxBackOff = 8;
 
 const char kUmaHashResponseMetricName[] = "SB2.GetHashResponseOrErrorCode";
 
 // The default SBProtocolManagerFactory.
 class SBProtocolManagerFactoryImpl : public SBProtocolManagerFactory {
  public:
-  SBProtocolManagerFactoryImpl() { }
+  SBProtocolManagerFactoryImpl() {}
   ~SBProtocolManagerFactoryImpl() override {}
   SafeBrowsingProtocolManager* CreateProtocolManager(
       SafeBrowsingProtocolManagerDelegate* delegate,
       net::URLRequestContextGetter* request_context_getter,
       const SafeBrowsingProtocolConfig& config) override {
-    return new SafeBrowsingProtocolManager(
-        delegate, request_context_getter, config);
+    return new SafeBrowsingProtocolManager(delegate, request_context_getter,
+                                           config);
   }
+
  private:
   DISALLOW_COPY_AND_ASSIGN(SBProtocolManagerFactoryImpl);
 };
 
 // SafeBrowsingProtocolManager implementation ----------------------------------
 
 // static
 SBProtocolManagerFactory* SafeBrowsingProtocolManager::factory_ = NULL;
 
 // static
 SafeBrowsingProtocolManager* SafeBrowsingProtocolManager::Create(
     SafeBrowsingProtocolManagerDelegate* delegate,
     net::URLRequestContextGetter* request_context_getter,
     const SafeBrowsingProtocolConfig& config) {
   // TODO(cbentzel): Remove ScopedTracker below once crbug.com/483689 is fixed.
   tracked_objects::ScopedTracker tracking_profile(
       FROM_HERE_WITH_EXPLICIT_FUNCTION(
           "483689 SafeBrowsingProtocolManager::Create"));
   if (!factory_)
     factory_ = new SBProtocolManagerFactoryImpl();
-  return factory_->CreateProtocolManager(
-      delegate, request_context_getter, config);
+  return factory_->CreateProtocolManager(delegate, request_context_getter,
+                                         config);
 }
 
 SafeBrowsingProtocolManager::SafeBrowsingProtocolManager(
     SafeBrowsingProtocolManagerDelegate* delegate,
     net::URLRequestContextGetter* request_context_getter,
     const SafeBrowsingProtocolConfig& config)
     : delegate_(delegate),
       request_type_(NO_REQUEST),
       update_error_count_(0),
       gethash_error_count_(0),
@@ skipping 21 matching lines @@
   backup_url_prefixes_[BACKUP_UPDATE_REASON_NETWORK] =
       config.backup_network_error_url_prefix;
 
   // Set the backoff multiplier fuzz to a random value between 0 and 1.
   back_off_fuzz_ = static_cast<float>(base::RandDouble());
   if (version_.empty())
     version_ = SafeBrowsingProtocolManagerHelper::Version();
 }
 
 // static
-void SafeBrowsingProtocolManager::RecordGetHashResult(
-    bool is_download, ResultType result_type) {
+void SafeBrowsingProtocolManager::RecordGetHashResult(bool is_download,
+                                                      ResultType result_type) {
   if (is_download) {
     UMA_HISTOGRAM_ENUMERATION("SB2.GetHashResultDownload", result_type,
                               GET_HASH_RESULT_MAX);
   } else {
     UMA_HISTOGRAM_ENUMERATION("SB2.GetHashResult", result_type,
                               GET_HASH_RESULT_MAX);
   }
 }
 
 void SafeBrowsingProtocolManager::RecordHttpResponseOrErrorCode(
-    const char* metric_name, const net::URLRequestStatus& status,
+    const char* metric_name,
+    const net::URLRequestStatus& status,
     int response_code) {
   UMA_HISTOGRAM_SPARSE_SLOWLY(
       metric_name, status.is_success() ? response_code : status.error());
 }
 
 bool SafeBrowsingProtocolManager::IsUpdateScheduled() const {
   return update_timer_.IsRunning();
 }
 
 SafeBrowsingProtocolManager::~SafeBrowsingProtocolManager() {
@@ skipping 17 matching lines @@
   // required to return empty results (i.e. treat the page as safe).
   if (gethash_error_count_ && Time::Now() <= next_gethash_time_) {
     RecordGetHashResult(is_download, GET_HASH_BACKOFF_ERROR);
     std::vector<SBFullHashResult> full_hashes;
     callback.Run(full_hashes, base::TimeDelta());
     return;
   }
   GURL gethash_url = GetHashUrl(is_extended_reporting);
   net::URLFetcher* fetcher =
       net::URLFetcher::Create(url_fetcher_id_++, gethash_url,
-                              net::URLFetcher::POST, this).release();
+                              net::URLFetcher::POST, this)
+          .release();
   hash_requests_[fetcher] = FullHashDetails(callback, is_download);
 
-  const std::string get_hash = safe_browsing::FormatGetHash(prefixes);
+  const std::string get_hash = FormatGetHash(prefixes);
 
   fetcher->SetLoadFlags(net::LOAD_DISABLE_CACHE);
   fetcher->SetRequestContext(request_context_getter_.get());
   fetcher->SetUploadData("text/plain", get_hash);
   fetcher->Start();
 }
 
 void SafeBrowsingProtocolManager::GetNextUpdate() {
   DCHECK(CalledOnValidThread());
   if (request_.get() || request_type_ != NO_REQUEST)
@@ skipping 13 matching lines @@
 //              do will report all the chunks we have. If that chunk is still
 //              required, the SafeBrowsing servers will tell us to get it again.
 void SafeBrowsingProtocolManager::OnURLFetchComplete(
     const net::URLFetcher* source) {
   DCHECK(CalledOnValidThread());
   scoped_ptr<const net::URLFetcher> fetcher;
 
   HashRequests::iterator it = hash_requests_.find(source);
   int response_code = source->GetResponseCode();
   net::URLRequestStatus status = source->GetStatus();
-  RecordHttpResponseOrErrorCode(
-      kUmaHashResponseMetricName, status, response_code);
+  RecordHttpResponseOrErrorCode(kUmaHashResponseMetricName, status,
+                                response_code);
   if (it != hash_requests_.end()) {
     // GetHash response.
     fetcher.reset(it->first);
     const FullHashDetails& details = it->second;
     std::vector<SBFullHashResult> full_hashes;
     base::TimeDelta cache_lifetime;
-    if (status.is_success() &&
-        (response_code == net::HTTP_OK ||
-         response_code == net::HTTP_NO_CONTENT)) {
+    if (status.is_success() && (response_code == net::HTTP_OK ||
+                                response_code == net::HTTP_NO_CONTENT)) {
       // For tracking our GetHash false positive (net::HTTP_NO_CONTENT) rate,
       // compared to real (net::HTTP_OK) responses.
       if (response_code == net::HTTP_OK)
         RecordGetHashResult(details.is_download, GET_HASH_STATUS_200);
       else
         RecordGetHashResult(details.is_download, GET_HASH_STATUS_204);
 
       gethash_error_count_ = 0;
       gethash_back_off_mult_ = 1;
       std::string data;
       source->GetResponseAsString(&data);
-      if (!safe_browsing::ParseGetHash(
-              data.data(), data.length(), &cache_lifetime, &full_hashes)) {
+      if (!ParseGetHash(data.data(), data.length(), &cache_lifetime,
+                        &full_hashes)) {
         full_hashes.clear();
         RecordGetHashResult(details.is_download, GET_HASH_PARSE_ERROR);
         // TODO(cbentzel): Should cache_lifetime be set to 0 here? (See
         // http://crbug.com/360232.)
       }
     } else {
       HandleGetHashError(Time::Now());
       if (status.status() == net::URLRequestStatus::FAILED) {
         RecordGetHashResult(details.is_download, GET_HASH_NETWORK_ERROR);
         DVLOG(1) << "SafeBrowsing GetHash request for: " << source->GetURL()
@@ skipping 27 matching lines @@
       timeout_timer_.Stop();
     }
 
     if (status.is_success() && response_code == net::HTTP_OK) {
       // We have data from the SafeBrowsing service.
       std::string data;
       source->GetResponseAsString(&data);
 
       // TODO(shess): Cleanup the flow of this code so that |parsed_ok| can be
       // removed or omitted.
-      const bool parsed_ok = HandleServiceResponse(
-          source->GetURL(), data.data(), data.length());
+      const bool parsed_ok =
+          HandleServiceResponse(source->GetURL(), data.data(), data.length());
       if (!parsed_ok) {
         DVLOG(1) << "SafeBrowsing request for: " << source->GetURL()
                  << " failed parse.";
         chunk_request_urls_.clear();
         if (request_type_ == UPDATE_REQUEST &&
             IssueBackupUpdateRequest(BACKUP_UPDATE_REASON_HTTP)) {
           return;
         }
         UpdateFinished(false);
       }
@@ skipping 53 matching lines @@
         }
       }
       UpdateFinished(false);
     }
   }
 
   // Get the next chunk if available.
   IssueChunkRequest();
 }
 
-bool SafeBrowsingProtocolManager::HandleServiceResponse(
-    const GURL& url, const char* data, size_t length) {
+bool SafeBrowsingProtocolManager::HandleServiceResponse(const GURL& url,
+                                                        const char* data,
+                                                        size_t length) {
   DCHECK(CalledOnValidThread());
 
   switch (request_type_) {
     case UPDATE_REQUEST:
     case BACKUP_UPDATE_REQUEST: {
       size_t next_update_sec = 0;
       bool reset = false;
-      scoped_ptr<std::vector<SBChunkDelete> > chunk_deletes(
+      scoped_ptr<std::vector<SBChunkDelete>> chunk_deletes(
           new std::vector<SBChunkDelete>);
       std::vector<ChunkUrl> chunk_urls;
-      if (!safe_browsing::ParseUpdate(data, length, &next_update_sec, &reset,
-                                      chunk_deletes.get(), &chunk_urls)) {
+      if (!ParseUpdate(data, length, &next_update_sec, &reset,
+                       chunk_deletes.get(), &chunk_urls)) {
         return false;
       }
 
       // New time for the next update.
       base::TimeDelta finch_next_update_interval =
           GetNextUpdateIntervalFromFinch();
       if (finch_next_update_interval > base::TimeDelta()) {
-          next_update_interval_ = finch_next_update_interval;
+        next_update_interval_ = finch_next_update_interval;
       } else {
         base::TimeDelta next_update_interval =
             base::TimeDelta::FromSeconds(next_update_sec);
         if (next_update_interval > base::TimeDelta()) {
           next_update_interval_ = next_update_interval;
         }
       }
       last_update_ = Time::Now();
 
       // New chunks to download.
@@ skipping 14 matching lines @@
       if (!chunk_deletes->empty())
         delegate_->DeleteChunks(chunk_deletes.Pass());
 
       break;
     }
     case CHUNK_REQUEST: {
       UMA_HISTOGRAM_TIMES("SB2.ChunkRequest",
                           base::Time::Now() - chunk_request_start_);
 
       const ChunkUrl chunk_url = chunk_request_urls_.front();
-      scoped_ptr<ScopedVector<SBChunkData> >
-          chunks(new ScopedVector<SBChunkData>);
+      scoped_ptr<ScopedVector<SBChunkData>> chunks(
+          new ScopedVector<SBChunkData>);
       UMA_HISTOGRAM_COUNTS("SB2.ChunkSize", length);
       update_size_ += length;
-      if (!safe_browsing::ParseChunk(data, length, chunks.get()))
+      if (!ParseChunk(data, length, chunks.get()))
         return false;
 
       // Chunks to add to storage.  Pass ownership of |chunks|.
       if (!chunks->empty()) {
         chunk_pending_to_write_ = true;
         delegate_->AddChunks(
             chunk_url.list_name, chunks.Pass(),
             base::Bind(&SafeBrowsingProtocolManager::OnAddChunksComplete,
                        base::Unretained(this)));
       }
@@ skipping 55 matching lines @@
     next = GetNextBackOffInterval(&update_error_count_, &update_back_off_mult_);
   } else {
     // Successful response means error reset.
     update_error_count_ = 0;
     update_back_off_mult_ = 1;
   }
   return next;
 }
 
 base::TimeDelta SafeBrowsingProtocolManager::GetNextBackOffInterval(
-    size_t* error_count, size_t* multiplier) const {
+    size_t* error_count,
+    size_t* multiplier) const {
   DCHECK(CalledOnValidThread());
   DCHECK(multiplier && error_count);
   (*error_count)++;
   if (*error_count > 1 && *error_count < 6) {
-    base::TimeDelta next = base::TimeDelta::FromMinutes(
-        *multiplier * (1 + back_off_fuzz_) * 30);
+    base::TimeDelta next =
+        base::TimeDelta::FromMinutes(*multiplier * (1 + back_off_fuzz_) * 30);
     *multiplier *= 2;
     if (*multiplier > kSbMaxBackOff)
       *multiplier = kSbMaxBackOff;
     return next;
   }
   if (*error_count >= 6)
     return base::TimeDelta::FromHours(8);
   return base::TimeDelta::FromMinutes(1);
 }
 
@@ skipping 72 matching lines @@
   if (database_error) {
     // The update was not successful, but don't back off.
     UpdateFinished(false, false);
     return;
   }
 
   // Format our stored chunks:
   bool found_malware = false;
   bool found_phishing = false;
   for (size_t i = 0; i < lists.size(); ++i) {
-    update_list_data_.append(safe_browsing::FormatList(lists[i]));
-    if (lists[i].name == safe_browsing::kPhishingList)
+    update_list_data_.append(FormatList(lists[i]));
+    if (lists[i].name == kPhishingList)
       found_phishing = true;
 
-    if (lists[i].name == safe_browsing::kMalwareList)
+    if (lists[i].name == kMalwareList)
       found_malware = true;
   }
 
   // If we have an empty database, let the server know we want data for these
   // lists.
   // TODO(shess): These cases never happen because the database fills in the
   // lists in GetChunks().  Refactor the unit tests so that this code can be
   // removed.
   if (!found_phishing) {
-    update_list_data_.append(safe_browsing::FormatList(
-        SBListChunkRanges(safe_browsing::kPhishingList)));
+    update_list_data_.append(FormatList(SBListChunkRanges(kPhishingList)));
   }
   if (!found_malware) {
-    update_list_data_.append(safe_browsing::FormatList(
-        SBListChunkRanges(safe_browsing::kMalwareList)));
+    update_list_data_.append(FormatList(SBListChunkRanges(kMalwareList)));
   }
 
   // Large requests are (probably) a sign of database corruption.
   // Record stats to inform decisions about whether to automate
   // deletion of such databases.  http://crbug.com/120219
   UMA_HISTOGRAM_COUNTS("SB2.UpdateRequestSize", update_list_data_.size());
 
   GURL update_url = UpdateUrl(is_extended_reporting);
   request_ = net::URLFetcher::Create(url_fetcher_id_++, update_url,
                                      net::URLFetcher::POST, this);
@@ skipping 29 matching lines @@
   if (chunk_request_urls_.empty()) {
     UMA_HISTOGRAM_LONG_TIMES("SB2.Update", Time::Now() - last_update_);
     UpdateFinished(true);
   } else {
     IssueChunkRequest();
   }
 }
 
 void SafeBrowsingProtocolManager::HandleGetHashError(const Time& now) {
   DCHECK(CalledOnValidThread());
-  base::TimeDelta next = GetNextBackOffInterval(
-      &gethash_error_count_, &gethash_back_off_mult_);
+  base::TimeDelta next =
+      GetNextBackOffInterval(&gethash_error_count_, &gethash_back_off_mult_);
   next_gethash_time_ = now + next;
 }
 
 void SafeBrowsingProtocolManager::UpdateFinished(bool success) {
   UpdateFinished(success, !success);
 }
 
 void SafeBrowsingProtocolManager::UpdateFinished(bool success, bool back_off) {
   DCHECK(CalledOnValidThread());
   UMA_HISTOGRAM_COUNTS("SB2.UpdateSize", update_size_);
   update_size_ = 0;
   bool update_success = success || request_type_ == CHUNK_REQUEST;
   if (backup_update_reason_ == BACKUP_UPDATE_REASON_MAX) {
-    RecordUpdateResult(
-        update_success ? UPDATE_RESULT_SUCCESS : UPDATE_RESULT_FAIL);
+    RecordUpdateResult(update_success ? UPDATE_RESULT_SUCCESS
+                                      : UPDATE_RESULT_FAIL);
   } else {
     UpdateResult update_result = static_cast<UpdateResult>(
-          UPDATE_RESULT_BACKUP_START +
-          (static_cast<int>(backup_update_reason_) * 2) +
-          update_success);
+        UPDATE_RESULT_BACKUP_START +
+        (static_cast<int>(backup_update_reason_) * 2) + update_success);
     RecordUpdateResult(update_result);
   }
   backup_update_reason_ = BACKUP_UPDATE_REASON_MAX;
   request_type_ = NO_REQUEST;
   update_list_data_.clear();
   delegate_->UpdateFinished(success);
   ScheduleNextUpdate(back_off);
 }
 
 GURL SafeBrowsingProtocolManager::UpdateUrl(bool is_extended_reporting) const {
@@ skipping 17 matching lines @@
 GURL SafeBrowsingProtocolManager::GetHashUrl(bool is_extended_reporting) const {
   std::string url = SafeBrowsingProtocolManagerHelper::ComposeUrl(
       url_prefix_, "gethash", client_name_, version_, additional_query_,
       is_extended_reporting);
   return GURL(url);
 }
 
 GURL SafeBrowsingProtocolManager::NextChunkUrl(const std::string& url) const {
   DCHECK(CalledOnValidThread());
   std::string next_url;
-  if (!base::StartsWith(url, "http://",
-                        base::CompareCase::INSENSITIVE_ASCII) &&
+  if (!base::StartsWith(url, "http://", base::CompareCase::INSENSITIVE_ASCII) &&
       !base::StartsWith(url, "https://",
                         base::CompareCase::INSENSITIVE_ASCII)) {
     // Use https if we updated via https, otherwise http (useful for testing).
     if (base::StartsWith(url_prefix_, "https://",
                          base::CompareCase::INSENSITIVE_ASCII))
       next_url.append("https://");
     else
       next_url.append("http://");
     next_url.append(url);
   } else {
     next_url = url;
   }
   if (!additional_query_.empty()) {
     if (next_url.find("?") != std::string::npos) {
       next_url.append("&");
     } else {
       next_url.append("?");
     }
     next_url.append(additional_query_);
   }
   return GURL(next_url);
 }
 
 SafeBrowsingProtocolManager::FullHashDetails::FullHashDetails()
-    : callback(),
-      is_download(false) {
-}
+    : callback(), is_download(false) {}
 
 SafeBrowsingProtocolManager::FullHashDetails::FullHashDetails(
-    FullHashCallback callback, bool is_download)
-    : callback(callback),
-      is_download(is_download) {
-}
+    FullHashCallback callback,
+    bool is_download)
+    : callback(callback), is_download(is_download) {}
 
-SafeBrowsingProtocolManager::FullHashDetails::~FullHashDetails() {
-}
+SafeBrowsingProtocolManager::FullHashDetails::~FullHashDetails() {}
 
-SafeBrowsingProtocolManagerDelegate::~SafeBrowsingProtocolManagerDelegate() {
-}
+SafeBrowsingProtocolManagerDelegate::~SafeBrowsingProtocolManagerDelegate() {}
+
+}  // namespace safe_browsing