Network service: Safe browsing check for sub-resources from renderer.

chrome/renderer/chrome_content_renderer_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/renderer/chrome_content_renderer_client.h"
 
 #include <memory>
 #include <utility>
 
 #include "base/bind.h"
@@ skipping 39 matching lines @@
 #include "chrome/renderer/net_benchmarking_extension.h"
 #include "chrome/renderer/page_load_metrics/metrics_render_frame_observer.h"
 #include "chrome/renderer/pepper/pepper_helper.h"
 #include "chrome/renderer/plugins/non_loadable_plugin_placeholder.h"
 #include "chrome/renderer/plugins/plugin_preroller.h"
 #include "chrome/renderer/plugins/plugin_uma.h"
 #include "chrome/renderer/prerender/prerender_dispatcher.h"
 #include "chrome/renderer/prerender/prerender_helper.h"
 #include "chrome/renderer/prerender/prerenderer_client.h"
 #include "chrome/renderer/safe_browsing/phishing_classifier_delegate.h"
+#include "chrome/renderer/safe_browsing/safe_browsing_url_loader_throttle.h"
 #include "chrome/renderer/searchbox/search_bouncer.h"
 #include "chrome/renderer/searchbox/searchbox.h"
 #include "chrome/renderer/searchbox/searchbox_extension.h"
 #include "chrome/renderer/tts_dispatcher.h"
 #include "chrome/renderer/worker_content_settings_client_proxy.h"
 #include "components/autofill/content/renderer/autofill_agent.h"
 #include "components/autofill/content/renderer/password_autofill_agent.h"
 #include "components/autofill/content/renderer/password_generation_agent.h"
 #include "components/content_settings/core/common/content_settings_pattern.h"
 #include "components/contextual_search/renderer/overlay_js_render_frame_observer.h"
@@ skipping 29 matching lines @@
 #include "extensions/features/features.h"
 #include "ipc/ipc_sync_channel.h"
 #include "media/base/media_switches.h"
 #include "media/media_features.h"
 #include "net/base/net_errors.h"
 #include "ppapi/c/private/ppb_pdf.h"
 #include "ppapi/features/features.h"
 #include "ppapi/shared_impl/ppapi_switches.h"
 #include "printing/features/features.h"
 #include "services/service_manager/public/cpp/connector.h"
+#include "services/service_manager/public/cpp/interface_provider.h"
 #include "third_party/WebKit/public/platform/URLConversion.h"
 #include "third_party/WebKit/public/platform/WebCache.h"
 #include "third_party/WebKit/public/platform/WebCachePolicy.h"
 #include "third_party/WebKit/public/platform/WebSecurityOrigin.h"
 #include "third_party/WebKit/public/platform/WebURL.h"
 #include "third_party/WebKit/public/platform/WebURLError.h"
 #include "third_party/WebKit/public/platform/WebURLRequest.h"
 #include "third_party/WebKit/public/platform/WebURLResponse.h"
 #include "third_party/WebKit/public/web/WebDataSource.h"
 #include "third_party/WebKit/public/web/WebDocument.h"
@@ skipping 218 matching lines @@
   // |module_event_sink|: it is owned by a ChromeContentRendererClient, which is
   // a leaked singleton in the process.
   io_task_runner->PostTask(
       FROM_HERE, base::Bind(&HandleModuleEventOnIOThread,
                             base::Unretained(module_event_sink), event));
 }
 #endif
 
 }  // namespace
 
+ChromeContentRendererClient::FrameData::FrameData() = default;
+ChromeContentRendererClient::FrameData::~FrameData() = default;
+
 ChromeContentRendererClient::ChromeContentRendererClient()
     : main_entry_time_(base::TimeTicks::Now()) {
 #if BUILDFLAG(ENABLE_EXTENSIONS)
   extensions::ExtensionsClient::Set(
       extensions::ChromeExtensionsClient::GetInstance());
   extensions::ExtensionsRendererClient::Set(
       ChromeExtensionsRendererClient::GetInstance());
 #endif
 #if BUILDFLAG(ENABLE_PLUGINS)
   for (size_t i = 0; i < arraysize(kPredefinedAllowedCameraDeviceOrigins); ++i)
@@ skipping 130 matching lines @@
   }
 
 #if defined(OS_CHROMEOS)
   leak_detector_remote_client_.reset(new LeakDetectorRemoteClient());
   thread->AddObserver(leak_detector_remote_client_.get());
 #endif
 }
 
 void ChromeContentRendererClient::RenderFrameCreated(
     content::RenderFrame* render_frame) {
-  new ChromeRenderFrameObserver(render_frame);
+  new ChromeRenderFrameObserver(this, render_frame);
 
   bool should_whitelist_for_content_settings =
       base::CommandLine::ForCurrentProcess()->HasSwitch(
           switches::kInstantProcess);
   extensions::Dispatcher* ext_dispatcher = NULL;
 #if BUILDFLAG(ENABLE_EXTENSIONS)
   ext_dispatcher =
       ChromeExtensionsRendererClient::GetInstance()->extension_dispatcher();
 #endif
   ContentSettingsObserver* content_settings = new ContentSettingsObserver(
@@ skipping 679 matching lines @@
     return true;
 #endif  // BUILDFLAG(ENABLE_EXTENSIONS)
 
   return false;
 }
 
 bool ChromeContentRendererClient::WillSendRequest(
     WebLocalFrame* frame,
     ui::PageTransition transition_type,
     const blink::WebURL& url,
-    GURL* new_url) {
+    GURL* new_url,
+    std::vector<std::unique_ptr<content::URLLoaderThrottle>>* throttles) {
 // Check whether the request should be allowed. If not allowed, we reset the
 // URL to something invalid to prevent the request and cause an error.
 #if BUILDFLAG(ENABLE_EXTENSIONS)
   if (ChromeExtensionsRendererClient::GetInstance()->WillSendRequest(
           frame, transition_type, url, new_url)) {
     return true;
   }
 #endif
 
+  if (base::CommandLine::ForCurrentProcess()->HasSwitch(
+          switches::kEnableNetworkService)) {
+    RenderFrame* render_frame = content::RenderFrame::FromWebFrame(frame);
+    auto& frame_data = frame_data_map_[render_frame];
+    if (!frame_data.safe_browsing) {
+      render_frame->GetRemoteInterfaces()->GetInterface(
+          &frame_data.safe_browsing);
+    }
+
+    // TODO(yzshen): Is it safe to assume that all URL requests will be aborted
+    // before the render frame goes away? Because that is when
+    // |frame_data.safe_browsing| goes away.

[kinuko, 2017/05/25 11:30:57]

This is actually not true (or not going to be true at least), but I'm not sure
how much problematic it could be.

[yzshen1, 2017/05/26 20:43:52]

Since URL loads may not always associated with render frames (thanks for telling
me that!), I changed the SafeBrowsing interface to be per-process instead of
per-frame. It is stored as a member variable of this class. I think that should
solve the lifespan issue.

Thanks! 

+    throttles->push_back(
+        base::MakeUnique<safe_browsing::SafeBrowsingURLLoaderThrottle>(
+            frame_data.safe_browsing.get()));
+  }
+
   if (!url.ProtocolIs(chrome::kChromeSearchScheme))
     return false;
 
   SearchBox* search_box =
       SearchBox::Get(content::RenderFrame::FromWebFrame(frame->LocalRoot()));
   if (search_box) {
     // Note: this GURL copy could be avoided if host() were added to WebURL.
     GURL gurl(url);
     SearchBox::ImageSourceType type = SearchBox::NONE;
     if (gurl.host_piece() == chrome::kChromeUIFaviconHost)
@@ skipping 354 matching lines @@
 
   RecordYouTubeRewriteUMA(result);
   return corrected_url.ReplaceComponents(r);
 }
 
 std::unique_ptr<base::TaskScheduler::InitParams>
 ChromeContentRendererClient::GetTaskSchedulerInitParams() {
   return task_scheduler_util::
       GetRendererTaskSchedulerInitParamsFromCommandLine();
 }
+
+void ChromeContentRendererClient::OnRenderFrameDestruct(
+    content::RenderFrame* frame) {
+  frame_data_map_.erase(frame);
+}