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

chrome/browser/chrome_content_browser_client.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/chrome_content_browser_client.h"
 
 #include <map>
 #include <set>
 #include <utility>
 #include <vector>
@@ skipping 543 matching lines @@
     return;
   popup_helper->AddBlockedPopup(params);
 }
 
 // An implementation of the SSLCertReporter interface used by
 // SSLErrorHandler. Uses the SafeBrowsing UI manager to send invalid
 // certificate reports.
 class SafeBrowsingSSLCertReporter : public SSLCertReporter {
  public:
   explicit SafeBrowsingSSLCertReporter(
-      const scoped_refptr<SafeBrowsingUIManager>& safe_browsing_ui_manager)
+      const scoped_refptr<safe_browsing::SafeBrowsingUIManager>&
+          safe_browsing_ui_manager)
       : safe_browsing_ui_manager_(safe_browsing_ui_manager) {}
   ~SafeBrowsingSSLCertReporter() override {}
 
   // SSLCertReporter implementation
   void ReportInvalidCertificateChain(
       const std::string& serialized_report) override {
     if (safe_browsing_ui_manager_) {
       safe_browsing_ui_manager_->ReportInvalidCertificateChain(
           serialized_report, base::Bind(&base::DoNothing));
     }
   }
 
  private:
-  const scoped_refptr<SafeBrowsingUIManager> safe_browsing_ui_manager_;
+  const scoped_refptr<safe_browsing::SafeBrowsingUIManager>
+      safe_browsing_ui_manager_;
 };
 
 #if defined(OS_ANDROID)
 
 void HandleSingleTabModeBlockOnUIThread(const BlockedWindowParams& params) {
   WebContents* web_contents = tab_util::GetWebContentsByFrameID(
       params.render_process_id(), params.opener_render_frame_id());
   if (!web_contents)
     return;
 
@@ skipping 1391 matching lines @@
   // Otherwise, display an SSL blocking page. The interstitial page takes
   // ownership of ssl_blocking_page.
   int options_mask = 0;
   if (overridable)
     options_mask |= SSLBlockingPage::OVERRIDABLE;
   if (strict_enforcement)
     options_mask |= SSLBlockingPage::STRICT_ENFORCEMENT;
   if (expired_previous_decision)
     options_mask |= SSLBlockingPage::EXPIRED_BUT_PREVIOUSLY_ALLOWED;
 
-  SafeBrowsingService* safe_browsing_service =
+  safe_browsing::SafeBrowsingService* safe_browsing_service =
       g_browser_process->safe_browsing_service();
   scoped_ptr<SafeBrowsingSSLCertReporter> cert_reporter(
       new SafeBrowsingSSLCertReporter(safe_browsing_service
                                           ? safe_browsing_service->ui_manager()
                                           : nullptr));
   SSLErrorHandler::HandleSSLError(tab, cert_error, ssl_info, request_url,
                                   options_mask, cert_reporter.Pass(), callback);
 }
 
 void ChromeContentBrowserClient::SelectClientCertificate(
@@ skipping 768 matching lines @@
   if (channel <= kMaxDisableEncryptionChannel) {
     static const char* const kWebRtcDevSwitchNames[] = {
       switches::kDisableWebRtcEncryption,
     };
     to_command_line->CopySwitchesFrom(from_command_line,
                                       kWebRtcDevSwitchNames,
                                       arraysize(kWebRtcDevSwitchNames));
   }
 }
 #endif  // defined(ENABLE_WEBRTC)