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

chrome/browser/renderer_host/data_reduction_proxy_resource_throttle_android.cc

 // Copyright 2015 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/data_reduction_proxy_resource_throttle_android.h"
 
 #include "base/logging.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/prerender/prerender_contents.h"
 #include "chrome/browser/profiles/profile_io_data.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/render_view_host.h"
 #include "content/public/browser/resource_context.h"
 #include "content/public/browser/resource_controller.h"
 #include "content/public/browser/resource_request_info.h"
 #include "content/public/browser/web_contents.h"
 #include "net/base/load_flags.h"
 #include "net/http/http_response_headers.h"
 #include "net/url_request/redirect_info.h"
 #include "net/url_request/url_request.h"
 
 using content::BrowserThread;
 using content::ResourceThrottle;
+using safe_browsing::SafeBrowsingService;
+using safe_browsing::SafeBrowsingUIManager;
+using safe_browsing::SBThreatType;
 
 // TODO(eroman): Downgrade these CHECK()s to DCHECKs once there is more
 //               unit test coverage.
 // TODO(sgurun) following the comment above, also provide tests for
 // checking whether the headers are injected correctly and the SPDY proxy
 // origin is tested properly.
 
 const char* DataReductionProxyResourceThrottle::kUnsafeUrlProceedHeader =
       "X-Unsafe-Url-Proceed";
 
@@ skipping 31 matching lines @@
 void DataReductionProxyResourceThrottle::WillRedirectRequest(
     const net::RedirectInfo& redirect_info,
     bool* defer) {
   CHECK(state_ == STATE_NONE);
 
   // Save the redirect urls for possible malware detail reporting later.
   redirect_urls_.push_back(redirect_info.new_url);
 
   // We need to check the new URL before following the redirect.
   SBThreatType threat_type = CheckUrl();
-  if (threat_type == SB_THREAT_TYPE_SAFE)
+  if (threat_type == safe_browsing::SB_THREAT_TYPE_SAFE)
     return;
 
   if (request_->load_flags() & net::LOAD_PREFETCH) {
     controller()->Cancel();
     return;
   }
   const content::ResourceRequestInfo* info =
       content::ResourceRequestInfo::ForRequest(request_);
 
   state_ = STATE_DISPLAYING_BLOCKING_PAGE;
@@ skipping 56 matching lines @@
   CHECK(state_ == STATE_DISPLAYING_BLOCKING_PAGE);
   state_ = STATE_NONE;
 
   if (proceed)
     ResumeRequest();
   else
     controller()->Cancel();
 }
 
 SBThreatType DataReductionProxyResourceThrottle::CheckUrl() {
-  SBThreatType result = SB_THREAT_TYPE_SAFE;
+  SBThreatType result = safe_browsing::SB_THREAT_TYPE_SAFE;
 
   // TODO(sgurun) Check for spdy proxy origin.
   if (request_->response_headers() == NULL)
     return result;
 
   if (request_->response_headers()->HasHeader("X-Phishing-Url"))
-    result = SB_THREAT_TYPE_URL_PHISHING;
+    result = safe_browsing::SB_THREAT_TYPE_URL_PHISHING;
   else if (request_->response_headers()->HasHeader("X-Malware-Url"))
-    result = SB_THREAT_TYPE_URL_MALWARE;
+    result = safe_browsing::SB_THREAT_TYPE_URL_MALWARE;
 
   // If safe browsing is disabled and the request is sent to the DRP server,
   // we need to break the redirect loop by setting the extra header.
-  if (result != SB_THREAT_TYPE_SAFE && !safe_browsing_->enabled()) {
+  if (result != safe_browsing::SB_THREAT_TYPE_SAFE &&
+      !safe_browsing_->enabled()) {
     request_->SetExtraRequestHeaderByName(kUnsafeUrlProceedHeader, "1", true);
-    result = SB_THREAT_TYPE_SAFE;
+    result = safe_browsing::SB_THREAT_TYPE_SAFE;
   }
 
   return result;
 }
 
 void DataReductionProxyResourceThrottle::ResumeRequest() {
   CHECK(state_ == STATE_NONE);
 
   // Inject the header before resuming the request.
   request_->SetExtraRequestHeaderByName(kUnsafeUrlProceedHeader, "1", true);
   controller()->Resume();
 }