[win] Enable ModuleDatabase behind a flag.

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 279 matching lines @@
     continue_loading_cb_.Run();
     delete this;
   }
   void OnDestruct() override { delete this; }
 
   const base::Closure continue_loading_cb_;
 
   DISALLOW_COPY_AND_ASSIGN(MediaLoadDeferrer);
 };
 
+#if defined(OS_WIN)
+// Dispatches a module |event| to the provided |module_event_sink| interface.
+// It is expected that this only be called from the IO thread. This is only
+// safe because the underlying |module_event_sink| object is never deleted,
+// being owned by the leaked ChromeContentRendererClient object. If this ever
+// changes then a WeakPtr mechanism would have to be used.
+void HandleModuleEventOnIOThread(mojom::ModuleEventSinkPtr* module_event_sink,
+                                 const ModuleWatcher::ModuleEvent& event) {
+  // Simply send the module load address. The browser can validate this and look
+  // up the module details on its own.
+  (*module_event_sink)
+      ->OnModuleEvent(event.event_type,
+                      reinterpret_cast<uintptr_t>(event.module_load_address));
+}
+
+// Receives notifications from the ModuleWatcher on any thread. Bounces these
+// over to the provided |io_task_runner| where they are subsequently dispatched
+// to the |module_event_sink| interface.
+void OnModuleEvent(scoped_refptr<base::SingleThreadTaskRunner> io_task_runner,
+                   mojom::ModuleEventSinkPtr* module_event_sink,
+                   const ModuleWatcher::ModuleEvent& event) {
+  // The Mojo interface can only be used from a single thread. Bounce tasks
+  // over to it. It is safe to pass an unretained pointer to
+  // |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::ChromeContentRendererClient()
     : main_entry_time_(base::TimeTicks::Now()) {
 #if BUILDFLAG(ENABLE_EXTENSIONS)
   extensions::ExtensionsClient::Set(
       extensions::ChromeExtensionsClient::GetInstance());
   extensions::ExtensionsRendererClient::Set(
       ChromeExtensionsRendererClient::GetInstance());
 #endif
@@ skipping 14 matching lines @@
 
 void ChromeContentRendererClient::RenderThreadStarted() {
   RenderThread* thread = RenderThread::Get();
 
   {
     startup_metric_utils::mojom::StartupMetricHostPtr startup_metric_host;
     thread->GetRemoteInterfaces()->GetInterface(&startup_metric_host);
     startup_metric_host->RecordRendererMainEntryTime(main_entry_time_);
   }
 
+#if defined(OS_WIN)
+  if (base::FeatureList::IsEnabled(features::kModuleDatabase)) {
+    thread->GetRemoteInterfaces()->GetInterface(&module_event_sink_);
+
+    // It is safe to pass an unretained pointer to |module_event_sink_|, as it
+    // is owned by the process singleton ChromeContentRendererClient, which is
+    // leaked.
+    module_watcher_ = ModuleWatcher::Create(
+        base::Bind(&OnModuleEvent, thread->GetIOTaskRunner(),
+                   base::Unretained(&module_event_sink_)));
+  }
+#endif
+
   chrome_observer_.reset(new ChromeRenderThreadObserver());
   web_cache_impl_.reset(new web_cache::WebCacheImpl());
 
 #if BUILDFLAG(ENABLE_EXTENSIONS)
   ChromeExtensionsRendererClient::GetInstance()->RenderThreadStarted();
 #endif
 
   prescient_networking_dispatcher_.reset(
       new network_hints::PrescientNetworkingDispatcher());
 #if BUILDFLAG(ENABLE_SPELLCHECK)
@@ skipping 1133 matching lines @@
     std::vector<base::SchedulerWorkerPoolParams>* params_vector,
     base::TaskScheduler::WorkerPoolIndexForTraitsCallback*
         index_to_traits_callback) {
   DCHECK(params_vector);
   DCHECK(index_to_traits_callback);
   // If this call fails, content will fall back to the default params.
   *params_vector = task_scheduler_util::GetRendererWorkerPoolParams();
   *index_to_traits_callback =
       base::Bind(&task_scheduler_util::RendererWorkerPoolIndexForTraits);
 }