Move SafeBrowsingUIManager::UnsafeResource to security_interstitials namespace

chrome/browser/safe_browsing/ui_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/ui_manager.h"
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/callback.h"
 #include "base/debug/leak_tracker.h"
@@ skipping 79 matching lines @@
  private:
   std::map<GURL, SBThreatType> map_;
   std::map<GURL, SBThreatType> pending_;
 
   DISALLOW_COPY_AND_ASSIGN(WhitelistUrlSet);
 };
 
 // Returns the URL that should be used in a WhitelistUrlSet for the given
 // |resource|.
 GURL GetMainFrameWhitelistUrlForResource(
-    const safe_browsing::SafeBrowsingUIManager::UnsafeResource& resource) {
+    const security_interstitials::UnsafeResource& resource) {
   if (resource.is_subresource) {
     NavigationEntry* entry = resource.GetNavigationEntryForResource();
     if (!entry)
       return GURL();
     return entry->GetURL().GetWithEmptyPath();
   }
   return resource.url.GetWithEmptyPath();
 }
 
 // Returns the URL that should be used in a WhitelistUrlSet for the
@@ skipping 16 matching lines @@
     site_list = new WhitelistUrlSet;
     web_contents->SetUserData(kWhitelistKey, site_list);
   }
   return site_list;
 }
 
 }  // namespace
 
 namespace safe_browsing {
 
-// SafeBrowsingUIManager::UnsafeResource ---------------------------------------
-
-SafeBrowsingUIManager::UnsafeResource::UnsafeResource()
-    : is_subresource(false),
-      is_subframe(false),
-      threat_type(SB_THREAT_TYPE_SAFE),
-      threat_source(safe_browsing::ThreatSource::UNKNOWN) {}
-
-SafeBrowsingUIManager::UnsafeResource::UnsafeResource(
-    const UnsafeResource& other) = default;
-
-SafeBrowsingUIManager::UnsafeResource::~UnsafeResource() { }
-
-bool SafeBrowsingUIManager::UnsafeResource::IsMainPageLoadBlocked() const {
-  // Subresource hits cannot happen until after main page load is committed.
-  if (is_subresource)
-    return false;
-
-  // Client-side phishing detection interstitials never block the main frame
-  // load, since they happen after the page is finished loading.
-  if (threat_type == SB_THREAT_TYPE_CLIENT_SIDE_PHISHING_URL ||
-      threat_type == SB_THREAT_TYPE_CLIENT_SIDE_MALWARE_URL) {
-    return false;
-  }
-
-  return true;
-}
-
-content::NavigationEntry*
-SafeBrowsingUIManager::UnsafeResource::GetNavigationEntryForResource() const {
-  content::WebContents* web_contents = web_contents_getter.Run();
-  if (!web_contents)
-    return nullptr;
-  // If a safebrowsing hit occurs during main frame navigation, the navigation
-  // will not be committed, and the pending navigation entry refers to the hit.
-  if (IsMainPageLoadBlocked())
-    return web_contents->GetController().GetPendingEntry();
-  // If a safebrowsing hit occurs on a subresource load, or on a main frame
-  // after the navigation is committed, the last committed navigation entry
-  // refers to the page with the hit. Note that there may concurrently be an
-  // unrelated pending navigation to another site, so GetActiveEntry() would be
-  // wrong.
-  return web_contents->GetController().GetLastCommittedEntry();
-}
-
-// static
-base::Callback<content::WebContents*(void)>
-SafeBrowsingUIManager::UnsafeResource::GetWebContentsGetter(
-    int render_process_host_id,
-    int render_frame_id) {
-  return base::Bind(&tab_util::GetWebContentsByFrameID, render_process_host_id,
-                    render_frame_id);
-}
-
-// SafeBrowsingUIManager -------------------------------------------------------
-
 SafeBrowsingUIManager::SafeBrowsingUIManager(
     const scoped_refptr<SafeBrowsingService>& service)
     : sb_service_(service) {}
 
 SafeBrowsingUIManager::~SafeBrowsingUIManager() {}
 
 void SafeBrowsingUIManager::StopOnIOThread(bool shutdown) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
 
   if (shutdown)
@@ skipping 335 matching lines @@
   bool whitelisted = site_list->Contains(lookup_url, threat_type);
   if (whitelist_only) {
     return whitelisted;
   } else {
     return whitelisted || site_list->ContainsPending(lookup_url, threat_type);
   }
 }
 
 // Static.
 GURL SafeBrowsingUIManager::GetMainFrameWhitelistUrlForResourceForTesting(
-    const safe_browsing::SafeBrowsingUIManager::UnsafeResource& resource) {
+    const security_interstitials::UnsafeResource& resource) {
   return GetMainFrameWhitelistUrlForResource(resource);
 }
 
 }  // namespace safe_browsing