Make UnsafeResource hold a WebContents getter instead of RenderFrame ids

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 51 matching lines @@
 
 }  // namespace
 
 namespace safe_browsing {
 
 // SafeBrowsingUIManager::UnsafeResource ---------------------------------------
 
 SafeBrowsingUIManager::UnsafeResource::UnsafeResource()
     : is_subresource(false),
       threat_type(SB_THREAT_TYPE_SAFE),
-      render_process_host_id(-1),
-      render_frame_id(MSG_ROUTING_NONE),
       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 {
-  WebContents* contents = tab_util::GetWebContentsByFrameID(
-      render_process_host_id, render_frame_id);
-  if (!contents)
+  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 contents->GetController().GetPendingEntry();
+    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 contents->GetController().GetLastCommittedEntry();
+  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() {}
 
@@ skipping 43 matching lines @@
         resource.callback_thread->PostTask(FROM_HERE,
                                            base::Bind(resource.callback, true));
       }
 
       return;
     }
   }
 
   // The tab might have been closed. If it was closed, just act as if "Don't
   // Proceed" had been chosen.
-  WebContents* web_contents = tab_util::GetWebContentsByFrameID(
-      resource.render_process_host_id, resource.render_frame_id);
+  WebContents* web_contents = resource.web_contents_getter.Run();
   if (!web_contents) {
     std::vector<UnsafeResource> resources;
     resources.push_back(resource);
     OnBlockingPageDone(resources, false);
     return;
   }
 
   // Check if the user has already ignored a SB warning for the same WebContents
   // and top-level domain.
   if (IsWhitelisted(resource)) {
@@ skipping 159 matching lines @@
   if (!serialized.empty()) {
     DVLOG(1) << "Sending serialized threat details.";
     sb_service_->ping_manager()->ReportThreatDetails(serialized);
   }
 }
 
 // Whitelist this domain in the current WebContents. Either add the
 // domain to an existing WhitelistUrlSet, or create a new WhitelistUrlSet.
 void SafeBrowsingUIManager::AddToWhitelist(const UnsafeResource& resource) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
-  WebContents* web_contents = tab_util::GetWebContentsByFrameID(
-      resource.render_process_host_id, resource.render_frame_id);
 
+  WebContents* web_contents = resource.web_contents_getter.Run();
   WhitelistUrlSet* site_list =
       static_cast<WhitelistUrlSet*>(web_contents->GetUserData(kWhitelistKey));
   if (!site_list) {
     site_list = new WhitelistUrlSet;
     web_contents->SetUserData(kWhitelistKey, site_list);
   }
 
   GURL whitelisted_url;
   if (resource.is_subresource) {
     NavigationEntry* entry = resource.GetNavigationEntryForResource();
     if (!entry)
       return;
     whitelisted_url = entry->GetURL();
   } else {
     whitelisted_url = resource.url;
   }
 
   site_list->Insert(whitelisted_url);
 }
 
 // Check if the user has already ignored a SB warning for this WebContents and
 // top-level domain.
 bool SafeBrowsingUIManager::IsWhitelisted(const UnsafeResource& resource) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
-  WebContents* web_contents = tab_util::GetWebContentsByFrameID(
-      resource.render_process_host_id, resource.render_frame_id);
 
   GURL maybe_whitelisted_url;
   if (resource.is_subresource) {
     NavigationEntry* entry = resource.GetNavigationEntryForResource();
     if (!entry)
       return false;
     maybe_whitelisted_url = entry->GetURL();
   } else {
     maybe_whitelisted_url = resource.url;
   }
 
-  WhitelistUrlSet* site_list =
-      static_cast<WhitelistUrlSet*>(web_contents->GetUserData(kWhitelistKey));
+  WhitelistUrlSet* site_list = static_cast<WhitelistUrlSet*>(
+      resource.web_contents_getter.Run()->GetUserData(kWhitelistKey));
   if (!site_list)
     return false;
   return site_list->Contains(maybe_whitelisted_url);
 }
 
 }  // namespace safe_browsing