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

chrome/browser/safe_browsing/threat_details.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.
 //
 // Implementation of the ThreatDetails class.
 
 #include "chrome/browser/safe_browsing/threat_details.h"
 
 #include "base/bind.h"
 #include "base/lazy_instance.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/safe_browsing/threat_details_cache.h"
 #include "chrome/browser/safe_browsing/threat_details_history.h"
 #include "chrome/common/safe_browsing/safebrowsing_messages.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/navigation_controller.h"
 #include "content/public/browser/navigation_entry.h"
 #include "content/public/browser/render_view_host.h"
 #include "content/public/browser/web_contents.h"
 #include "net/url_request/url_request_context_getter.h"
 
 using content::BrowserThread;
 using content::NavigationEntry;
 using content::WebContents;
-using safe_browsing::ClientSafeBrowsingReportRequest;
 
 // Keep in sync with KMaxNodes in renderer/safe_browsing/threat_dom_details
 static const uint32 kMaxDomNodes = 500;
 
+namespace safe_browsing {
+
 // static
 ThreatDetailsFactory* ThreatDetails::factory_ = NULL;
 
 namespace {
 
 // Helper function that converts SBThreatType to
 // ClientSafeBrowsingReportRequest::ReportType.
 ClientSafeBrowsingReportRequest::ReportType GetReportTypeFromSBThreatType(
     SBThreatType threat_type) {
   switch (threat_type) {
@@ skipping 82 matching lines @@
   // TODO(panayiotis): also skip internal urls.
   return url.SchemeIs("http") || url.SchemeIs("https");
 }
 
 // Looks for a Resource for the given url in resources_.  If found, it
 // updates |resource|. Otherwise, it creates a new message, adds it to
 // resources_ and updates |resource| to point to it.
 //
 ClientSafeBrowsingReportRequest::Resource* ThreatDetails::FindOrCreateResource(
     const GURL& url) {
-  safe_browsing::ResourceMap::iterator it = resources_.find(url.spec());
+  ResourceMap::iterator it = resources_.find(url.spec());
   if (it != resources_.end())
     return it->second.get();
 
   // Create the resource for |url|.
   int id = resources_.size();
   linked_ptr<ClientSafeBrowsingReportRequest::Resource> new_resource(
       new ClientSafeBrowsingReportRequest::Resource());
   new_resource->set_url(url.spec());
   new_resource->set_id(id);
   resources_[url.spec()] = new_resource;
@@ skipping 127 matching lines @@
 // closed the tab, or clicked proceed or goback.  Since the user needs
 // to take an action, we expect this to be called after
 // OnReceivedThreatDOMDetails in most cases. If not, we don't include
 // the DOM data in our report.
 void ThreatDetails::FinishCollection(bool did_proceed, int num_visit) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
 
   did_proceed_ = did_proceed;
   num_visits_ = num_visit;
   std::vector<GURL> urls;
-  for (safe_browsing::ResourceMap::const_iterator it = resources_.begin();
+  for (ResourceMap::const_iterator it = resources_.begin();
        it != resources_.end(); ++it) {
     urls.push_back(GURL(it->first));
   }
   redirects_collector_->StartHistoryCollection(
       urls, base::Bind(&ThreatDetails::OnRedirectionCollectionReady, this));
 }
 
 void ThreatDetails::OnRedirectionCollectionReady() {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
-  const std::vector<safe_browsing::RedirectChain>& redirects =
+  const std::vector<RedirectChain>& redirects =
       redirects_collector_->GetCollectedUrls();
 
   for (size_t i = 0; i < redirects.size(); ++i)
     AddRedirectUrlList(redirects[i]);
 
   // Call the cache collector
   cache_collector_->StartCacheCollection(
       request_context_getter_.get(), &resources_, &cache_result_,
       base::Bind(&ThreatDetails::OnCacheCollectionReady, this));
 }
 
 void ThreatDetails::AddRedirectUrlList(const std::vector<GURL>& urls) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   for (size_t i = 0; i < urls.size() - 1; ++i) {
     AddUrl(urls[i], urls[i + 1], std::string(), NULL);
   }
 }
 
 void ThreatDetails::OnCacheCollectionReady() {
   DVLOG(1) << "OnCacheCollectionReady.";
   // Add all the urls in our |resources_| maps to the |report_| protocol buffer.
-  for (safe_browsing::ResourceMap::const_iterator it = resources_.begin();
+  for (ResourceMap::const_iterator it = resources_.begin();
        it != resources_.end(); ++it) {
     ClientSafeBrowsingReportRequest::Resource* pb_resource =
         report_->add_resources();
     pb_resource->CopyFrom(*(it->second));
     const GURL url(pb_resource->url());
     if (url.SchemeIs("https")) {
       // Don't report headers of HTTPS requests since they may contain private
       // cookies.  We still retain the full URL.
       DVLOG(1) << "Clearing out HTTPS resource: " << pb_resource->url();
       pb_resource->clear_request();
       pb_resource->clear_response();
       // Keep id, parent_id, child_ids, and tag_name.
     }
   }
   report_->set_did_proceed(did_proceed_);
   // Only sets repeat_visit if num_visits_ >= 0.
   if (num_visits_ >= 0) {
     report_->set_repeat_visit(num_visits_ > 0);
   }
   report_->set_complete(cache_result_);
 
   // Send the report, using the SafeBrowsingService.
   std::string serialized;
   if (!report_->SerializeToString(&serialized)) {
     DLOG(ERROR) << "Unable to serialize the threat report.";
     return;
   }
   ui_manager_->SendSerializedThreatDetails(serialized);
 }
+
+}  // namespace safe_browsing