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

chrome/browser/renderer_host/safe_browsing_resource_throttle.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/renderer_host/safe_browsing_resource_throttle.h"
 
 #include "base/logging.h"
 #include "base/metrics/histogram_macros.h"
 #include "base/values.h"
 #include "chrome/browser/browser_process.h"
@@ skipping 53 matching lines @@
 
 }  // namespace
 
 // TODO(eroman): Downgrade these CHECK()s to DCHECKs once there is more
 //               unit test coverage.
 
 // static
 SafeBrowsingResourceThrottle* SafeBrowsingResourceThrottle::MaybeCreate(
     net::URLRequest* request,
     content::ResourceType resource_type,
-    SafeBrowsingService* sb_service) {
+    safe_browsing::SafeBrowsingService* sb_service) {
   if (sb_service->database_manager()->IsSupported()) {
     return new SafeBrowsingResourceThrottle(request, resource_type, sb_service);
   }
   return nullptr;
 }
 
 SafeBrowsingResourceThrottle::SafeBrowsingResourceThrottle(
     const net::URLRequest* request,
     content::ResourceType resource_type,
-    SafeBrowsingService* sb_service)
+    safe_browsing::SafeBrowsingService* sb_service)
     : state_(STATE_NONE),
       defer_state_(DEFERRED_NONE),
-      threat_type_(SB_THREAT_TYPE_SAFE),
+      threat_type_(safe_browsing::SB_THREAT_TYPE_SAFE),
       database_manager_(sb_service->database_manager()),
       ui_manager_(sb_service->ui_manager()),
       request_(request),
       resource_type_(resource_type),
       bound_net_log_(net::BoundNetLog::Make(request->net_log().net_log(),
                                             NetLog::SOURCE_SAFE_BROWSING)) {}
 
 SafeBrowsingResourceThrottle::~SafeBrowsingResourceThrottle() {
   if (defer_state_ != DEFERRED_NONE) {
     EndNetLogEvent(NetLog::TYPE_SAFE_BROWSING_DEFERRED, nullptr, nullptr);
@@ skipping 96 matching lines @@
 }
 
 const char* SafeBrowsingResourceThrottle::GetNameForLogging() const {
   return "SafeBrowsingResourceThrottle";
 }
 
 // SafeBrowsingService::Client implementation, called on the IO thread once
 // the URL has been classified.
 void SafeBrowsingResourceThrottle::OnCheckBrowseUrlResult(
     const GURL& url,
-    SBThreatType threat_type,
+    safe_browsing::SBThreatType threat_type,
     const std::string& metadata) {
   CHECK_EQ(state_, STATE_CHECKING_URL);
   CHECK_EQ(url, url_being_checked_);
 
   timer_.Stop();  // Cancel the timeout timer.
   threat_type_ = threat_type;
   state_ = STATE_NONE;
 
   if (defer_state_ != DEFERRED_NONE) {
     EndNetLogEvent(NetLog::TYPE_SAFE_BROWSING_DEFERRED, nullptr, nullptr);
   }
-  EndNetLogEvent(NetLog::TYPE_SAFE_BROWSING_CHECKING_URL, "result",
-                 threat_type_ == SB_THREAT_TYPE_SAFE ? "safe" : "unsafe");
+  EndNetLogEvent(
+      NetLog::TYPE_SAFE_BROWSING_CHECKING_URL, "result",
+      threat_type_ == safe_browsing::SB_THREAT_TYPE_SAFE ? "safe" : "unsafe");
 
-  if (threat_type == SB_THREAT_TYPE_SAFE) {
+  if (threat_type == safe_browsing::SB_THREAT_TYPE_SAFE) {
     RecordHistogramResourceTypeSafe(resource_type_);
     if (defer_state_ != DEFERRED_NONE) {
       // Log how much time the safe browsing check cost us.
       ui_manager_->LogPauseDelay(base::TimeTicks::Now() - defer_start_time_);
       ResumeRequest();
     } else {
       ui_manager_->LogPauseDelay(base::TimeDelta());
     }
     return;
   }
 
   if (request_->load_flags() & net::LOAD_PREFETCH) {
     // Don't prefetch resources that fail safe browsing, disallow them.
     controller()->Cancel();
     UMA_HISTOGRAM_ENUMERATION("SB2.ResourceTypes.UnsafePrefetchCanceled",
                               resource_type_, content::RESOURCE_TYPE_LAST_TYPE);
     return;
   }
 
   UMA_HISTOGRAM_ENUMERATION("SB2.ResourceTypes.Unsafe", resource_type_,
                             content::RESOURCE_TYPE_LAST_TYPE);
 
   const content::ResourceRequestInfo* info =
       content::ResourceRequestInfo::ForRequest(request_);
 
-  SafeBrowsingUIManager::UnsafeResource resource;
+  safe_browsing::SafeBrowsingUIManager::UnsafeResource resource;
   resource.url = url;
   resource.original_url = request_->original_url();
   resource.redirect_urls = redirect_urls_;
   resource.is_subresource = resource_type_ != content::RESOURCE_TYPE_MAIN_FRAME;
   resource.is_subframe = resource_type_ == content::RESOURCE_TYPE_SUB_FRAME;
   resource.threat_type = threat_type;
   resource.threat_metadata = metadata;
   resource.callback = base::Bind(
       &SafeBrowsingResourceThrottle::OnBlockingPageComplete, AsWeakPtr());
   resource.render_process_host_id = info->GetChildID();
   resource.render_view_id = info->GetRouteID();
-  resource.threat_source = SafeBrowsingUIManager::FROM_DEVICE;
+  resource.threat_source = safe_browsing::SafeBrowsingUIManager::FROM_DEVICE;
 
   state_ = STATE_DISPLAYING_BLOCKING_PAGE;
 
   content::BrowserThread::PostTask(
       content::BrowserThread::UI,
       FROM_HERE,
       base::Bind(&SafeBrowsingResourceThrottle::StartDisplayingBlockingPage,
                  AsWeakPtr(), ui_manager_, resource));
 }
 
 void SafeBrowsingResourceThrottle::StartDisplayingBlockingPage(
     const base::WeakPtr<SafeBrowsingResourceThrottle>& throttle,
-    scoped_refptr<SafeBrowsingUIManager> ui_manager,
-    const SafeBrowsingUIManager::UnsafeResource& resource) {
+    scoped_refptr<safe_browsing::SafeBrowsingUIManager> ui_manager,
+    const safe_browsing::SafeBrowsingUIManager::UnsafeResource& resource) {
   content::RenderViewHost* rvh = content::RenderViewHost::FromID(
       resource.render_process_host_id, resource.render_view_id);
   if (rvh) {
     content::WebContents* web_contents =
         content::WebContents::FromRenderViewHost(rvh);
     prerender::PrerenderContents* prerender_contents =
         prerender::PrerenderContents::FromWebContents(web_contents);
 
     if (prerender_contents) {
       prerender_contents->Destroy(prerender::FINAL_STATUS_SAFE_BROWSING);
@@ skipping 15 matching lines @@
 }
 
 // SafeBrowsingService::UrlCheckCallback implementation, called on the IO
 // thread when the user has decided to proceed with the current request, or
 // go back.
 void SafeBrowsingResourceThrottle::OnBlockingPageComplete(bool proceed) {
   CHECK_EQ(state_, STATE_DISPLAYING_BLOCKING_PAGE);
   state_ = STATE_NONE;
 
   if (proceed) {
-    threat_type_ = SB_THREAT_TYPE_SAFE;
+    threat_type_ = safe_browsing::SB_THREAT_TYPE_SAFE;
     if (defer_state_ != DEFERRED_NONE) {
       ResumeRequest();
     }
   } else {
     controller()->Cancel();
   }
 }
 
 bool SafeBrowsingResourceThrottle::CheckUrl(const GURL& url) {
   CHECK_EQ(state_, STATE_NONE);
   // To reduce aggregate latency on mobile, check only the most dangerous
   // resource types.
   if (!database_manager_->CanCheckResourceType(resource_type_)) {
     UMA_HISTOGRAM_ENUMERATION("SB2.ResourceTypes.Skipped", resource_type_,
                               content::RESOURCE_TYPE_LAST_TYPE);
     return true;
   }
 
   bool succeeded_synchronously = database_manager_->CheckBrowseUrl(url, this);
   UMA_HISTOGRAM_ENUMERATION("SB2.ResourceTypes.Checked", resource_type_,
                             content::RESOURCE_TYPE_LAST_TYPE);
 
   if (succeeded_synchronously) {
     RecordHistogramResourceTypeSafe(resource_type_);
-    threat_type_ = SB_THREAT_TYPE_SAFE;
+    threat_type_ = safe_browsing::SB_THREAT_TYPE_SAFE;
     ui_manager_->LogPauseDelay(base::TimeDelta());  // No delay.
     return true;
   }
 
   state_ = STATE_CHECKING_URL;
   url_being_checked_ = url;
   BeginNetLogEvent(NetLog::TYPE_SAFE_BROWSING_CHECKING_URL, url, nullptr,
                    nullptr);
 
   // Start a timer to abort the check if it takes too long.
   // TODO(nparker): Set this only when we defer, based on remaining time,
   // so we don't cancel earlier than necessary.
   timer_.Start(FROM_HERE,
                base::TimeDelta::FromMilliseconds(kCheckUrlTimeoutMs),
                this, &SafeBrowsingResourceThrottle::OnCheckUrlTimeout);
 
   return false;
 }
 
 void SafeBrowsingResourceThrottle::OnCheckUrlTimeout() {
   CHECK_EQ(state_, STATE_CHECKING_URL);
 
   database_manager_->CancelCheck(this);
   OnCheckBrowseUrlResult(
-      url_being_checked_, SB_THREAT_TYPE_SAFE, std::string());
+      url_being_checked_, safe_browsing::SB_THREAT_TYPE_SAFE, std::string());
 }
 
 void SafeBrowsingResourceThrottle::ResumeRequest() {
   CHECK_EQ(state_, STATE_NONE);
   CHECK_NE(defer_state_, DEFERRED_NONE);
 
   bool resume = true;
   if (defer_state_ == DEFERRED_UNCHECKED_REDIRECT) {
     // Save the redirect urls for possible malware detail reporting later.
     redirect_urls_.push_back(unchecked_redirect_url_);
     if (!CheckUrl(unchecked_redirect_url_)) {
       // We're now waiting for the unchecked_redirect_url_.
       defer_state_ = DEFERRED_REDIRECT;
       resume = false;
       BeginNetLogEvent(NetLog::TYPE_SAFE_BROWSING_DEFERRED,
                        unchecked_redirect_url_, "defer_reason",
                        "resumed_redirect");
     }
   }
 
   if (resume) {
     defer_state_ = DEFERRED_NONE;
     controller()->Resume();
   }
 }