Update to Chromium version 80.0.3987.0 (#722274)

libcef/renderer/content_renderer_client.cc

@@ -34,7 +34,6 @@
 #include "libcef/renderer/extensions/extensions_renderer_client.h"
 #include "libcef/renderer/extensions/print_render_frame_helper_delegate.h"
 #include "libcef/renderer/render_frame_observer.h"
-#include "libcef/renderer/render_message_filter.h"
 #include "libcef/renderer/render_thread_observer.h"
 #include "libcef/renderer/thread_util.h"
 #include "libcef/renderer/url_loader_throttle_provider_impl.h"
@@ -52,6 +51,7 @@
 #include "build/build_config.h"
 #include "chrome/common/chrome_switches.h"
 #include "chrome/common/url_constants.h"
+#include "chrome/renderer/browser_exposed_renderer_interfaces.h"
 #include "chrome/renderer/chrome_content_renderer_client.h"
 #include "chrome/renderer/extensions/chrome_extensions_renderer_client.h"
 #include "chrome/renderer/loadtimes_extension_bindings.h"
@@ -65,7 +65,7 @@
 #include "components/spellcheck/renderer/spellcheck.h"
 #include "components/spellcheck/renderer/spellcheck_provider.h"
 #include "components/startup_metric_utils/common/startup_metric.mojom.h"
-#include "components/visitedlink/renderer/visitedlink_slave.h"
+#include "components/visitedlink/renderer/visitedlink_reader.h"
 #include "components/web_cache/renderer/web_cache_impl.h"
 #include "content/common/frame_messages.h"
 #include "content/public/browser/browser_task_traits.h"
@@ -75,7 +75,7 @@
 #include "content/public/common/content_constants.h"
 #include "content/public/common/content_paths.h"
 #include "content/public/common/content_switches.h"
-#include "content/public/common/mime_handler_view_mode.h"
+#include "content/public/common/url_constants.h"
 #include "content/public/renderer/plugin_instance_throttler.h"
 #include "content/public/renderer/render_view.h"
 #include "content/public/renderer/render_view_visitor.h"
@@ -85,6 +85,7 @@
 #include "extensions/renderer/renderer_extension_registry.h"
 #include "ipc/ipc_sync_channel.h"
 #include "media/base/media.h"
+#include "mojo/public/cpp/bindings/binder_map.h"
 #include "mojo/public/cpp/bindings/generic_pending_receiver.h"
 #include "printing/print_settings.h"
 #include "services/network/public/cpp/is_potentially_trustworthy.h"
@@ -381,8 +382,9 @@ void CefContentRendererClient::RenderThreadStarted() {
       base::CommandLine::ForCurrentProcess();
 
   render_task_runner_ = base::ThreadTaskRunnerHandle::Get();
-  observer_.reset(new CefRenderThreadObserver());
-  web_cache_impl_.reset(new web_cache::WebCacheImpl());
+  observer_ = std::make_unique<CefRenderThreadObserver>();
+  web_cache_impl_ = std::make_unique<web_cache::WebCacheImpl>();
+  visited_link_slave_ = std::make_unique<visitedlink::VisitedLinkReader>();
 
   content::RenderThread* thread = content::RenderThread::Get();
 
@@ -399,10 +401,9 @@ void CefContentRendererClient::RenderThreadStarted() {
   }
 
   thread->AddObserver(observer_.get());
-  thread->GetChannel()->AddFilter(new CefRenderMessageFilter);
 
   if (!command_line->HasSwitch(switches::kDisableSpellChecking)) {
-    spellcheck_ = std::make_unique<SpellCheck>(&registry_, this);
+    spellcheck_ = std::make_unique<SpellCheck>(this);
   }
 
   if (content::RenderProcessHost::run_renderer_in_process()) {
@@ -445,6 +446,27 @@ void CefContentRendererClient::RenderThreadStarted() {
     extensions_renderer_client_->RenderThreadStarted();
 }
 
+void CefContentRendererClient::ExposeInterfacesToBrowser(
+    mojo::BinderMap* binders) {
+  auto task_runner = base::SequencedTaskRunnerHandle::Get();
+
+  binders->Add(base::BindRepeating(&web_cache::WebCacheImpl::BindReceiver,
+                                   base::Unretained(web_cache_impl_.get())),
+               task_runner);
+
+  binders->Add(visited_link_slave_->GetBindCallback(), task_runner);
+
+  if (spellcheck_) {
+    binders->Add(
+        base::BindRepeating(
+            [](SpellCheck* spellcheck,
+               mojo::PendingReceiver<spellcheck::mojom::SpellChecker>
+                   receiver) { spellcheck->BindReceiver(std::move(receiver)); },
+            base::Unretained(spellcheck_.get())),
+        task_runner);
+  }
+}
+
 void CefContentRendererClient::RenderThreadConnected() {
   content::RenderThread* thread = content::RenderThread::Get();
 
@@ -533,8 +555,6 @@ bool CefContentRendererClient::IsPluginHandledExternally(
 
   DCHECK(plugin_element.HasHTMLTagName("object") ||
          plugin_element.HasHTMLTagName("embed"));
-  if (!content::MimeHandlerViewMode::UsesCrossProcessFrame())
-    return false;
   // Blink will next try to load a WebPlugin which would end up in
   // OverrideCreatePlugin, sending another IPC only to find out the plugin is
   // not supported. Here it suffices to return false but there should perhaps be
@@ -589,13 +609,14 @@ void CefContentRendererClient::WillSendRequest(
     blink::WebLocalFrame* frame,
     ui::PageTransition transition_type,
     const blink::WebURL& url,
+    const blink::WebURL& site_for_cookies,
     const url::Origin* initiator_origin,
     GURL* new_url,
     bool* attach_same_site_cookies) {
   if (extensions::ExtensionsEnabled()) {
-    extensions_renderer_client_->WillSendRequest(frame, transition_type, url,
-                                                 initiator_origin, new_url,
-                                                 attach_same_site_cookies);
+    extensions_renderer_client_->WillSendRequest(
+        frame, transition_type, url, site_for_cookies, initiator_origin,
+        new_url, attach_same_site_cookies);
     if (!new_url->is_empty())
       return;
   }
@@ -603,12 +624,11 @@ void CefContentRendererClient::WillSendRequest(
 
 uint64_t CefContentRendererClient::VisitedLinkHash(const char* canonical_url,
                                                    size_t length) {
-  return observer_->visited_link_slave()->ComputeURLFingerprint(canonical_url,
-                                                                length);
+  return visited_link_slave_->ComputeURLFingerprint(canonical_url, length);
 }
 
 bool CefContentRendererClient::IsLinkVisited(uint64_t link_hash) {
-  return observer_->visited_link_slave()->IsVisited(link_hash);
+  return visited_link_slave_->IsVisited(link_hash);
 }
 
 bool CefContentRendererClient::IsOriginIsolatedPepperPlugin(
@@ -688,13 +708,11 @@ CefContentRendererClient::CreateURLLoaderThrottleProvider(
   return std::make_unique<CefURLLoaderThrottleProviderImpl>(provider_type);
 }
 
-void CefContentRendererClient::BindReceiverOnMainThread(
-    mojo::GenericPendingReceiver receiver) {
-  // TODO(crbug.com/977637): Get rid of the use of BinderRegistry here. This is
-  // only used to bind a spellcheck interface.
-  std::string interface_name = *receiver.interface_name();
-  auto pipe = receiver.PassPipe();
-  registry_.TryBindInterface(interface_name, &pipe);
+bool CefContentRendererClient::RequiresWebComponentsV0(const GURL& url) {
+  // TODO(1025782): For now, file:// URLs are allowed to access Web Components
+  // v0 features. This will be removed once origin trials support file:// URLs
+  // for this purpose.
+  return url.SchemeIs(content::kChromeUIScheme) || url.SchemeIs("file");
 }
 
 void CefContentRendererClient::GetInterface(

libcef/renderer/content_renderer_client.h

@@ -23,7 +23,6 @@
 #include "content/public/renderer/content_renderer_client.h"
 #include "content/public/renderer/render_thread.h"
 #include "mojo/public/cpp/bindings/generic_pending_receiver.h"
-#include "services/service_manager/public/cpp/binder_registry.h"
 #include "services/service_manager/public/cpp/local_interface_provider.h"
 
 namespace blink {
@@ -40,6 +39,10 @@ class ExtensionsRendererClient;
 class ResourceRequestPolicy;
 }  // namespace extensions
 
+namespace visitedlink {
+class VisitedLinkReader;
+}
+
 namespace web_cache {
 class WebCacheImpl;
 }
@@ -101,6 +104,7 @@ class CefContentRendererClient
 
   // ContentRendererClient implementation.
   void RenderThreadStarted() override;
+  void ExposeInterfacesToBrowser(mojo::BinderMap* binders) override;
   void RenderThreadConnected() override;
   void RenderFrameCreated(content::RenderFrame* render_frame) override;
   void RenderViewCreated(content::RenderView* render_view) override;
@@ -114,6 +118,7 @@ class CefContentRendererClient
   void WillSendRequest(blink::WebLocalFrame* frame,
                        ui::PageTransition transition_type,
                        const blink::WebURL& url,
+                       const blink::WebURL& site_for_cookies,
                        const url::Origin* initiator_origin,
                        GURL* new_url,
                        bool* attach_same_site_cookies) override;
@@ -136,7 +141,7 @@ class CefContentRendererClient
   std::unique_ptr<content::URLLoaderThrottleProvider>
   CreateURLLoaderThrottleProvider(
       content::URLLoaderThrottleProviderType provider_type) override;
-  void BindReceiverOnMainThread(mojo::GenericPendingReceiver receiver) override;
+  bool RequiresWebComponentsV0(const GURL& url) override;
 
   // service_manager::LocalInterfaceProvider implementation.
   void GetInterface(const std::string& name,
@@ -164,6 +169,7 @@ class CefContentRendererClient
   std::unique_ptr<CefRenderThreadObserver> observer_;
   std::unique_ptr<web_cache::WebCacheImpl> web_cache_impl_;
   std::unique_ptr<SpellCheck> spellcheck_;
+  std::unique_ptr<visitedlink::VisitedLinkReader> visited_link_slave_;
 
   std::unique_ptr<blink::WebURLLoaderFactory> default_url_loader_factory_;
 
@@ -194,8 +200,6 @@ class CefContentRendererClient
   bool single_process_cleanup_complete_;
   base::Lock single_process_cleanup_lock_;
 
-  service_manager::BinderRegistry registry_;
-
   DISALLOW_COPY_AND_ASSIGN(CefContentRendererClient);
 };
 

libcef/renderer/extensions/extensions_renderer_client.cc

@@ -122,6 +122,7 @@ void CefExtensionsRendererClient::WillSendRequest(
     blink::WebLocalFrame* frame,
     ui::PageTransition transition_type,
     const blink::WebURL& url,
+    const blink::WebURL& site_for_cookies,
     const url::Origin* initiator_origin,
     GURL* new_url,
     bool* attach_same_site_cookies) {

libcef/renderer/extensions/extensions_renderer_client.h

@@ -64,6 +64,7 @@ class CefExtensionsRendererClient : public ExtensionsRendererClient {
   void WillSendRequest(blink::WebLocalFrame* frame,
                        ui::PageTransition transition_type,
                        const blink::WebURL& url,
+                       const blink::WebURL& site_for_cookies,
                        const url::Origin* initiator_origin,
                        GURL* new_url,
                        bool* attach_same_site_cookies);

libcef/renderer/frame_impl.cc

@@ -337,10 +337,6 @@ void CefFrameImpl::OnDidFinishLoad() {
   }
 }
 
-void CefFrameImpl::OnFocused() {
-  Send(new CefHostMsg_FrameFocused(MSG_ROUTING_NONE));
-}
-
 void CefFrameImpl::OnDraggableRegionsChanged() {
   blink::WebVector<blink::WebDraggableRegion> webregions =
       frame_->GetDocument().DraggableRegions();

libcef/renderer/frame_impl.h

@@ -80,7 +80,6 @@ class CefFrameImpl : public CefFrame {
   void OnAttached();
   bool OnMessageReceived(const IPC::Message& message);
   void OnDidFinishLoad();
-  void OnFocused();
   void OnDraggableRegionsChanged();
   void OnDetached();
 

libcef/renderer/render_frame_observer.cc

@@ -84,12 +84,6 @@ void CefRenderFrameObserver::FrameDetached() {
   }
 }
 
-void CefRenderFrameObserver::FrameFocused() {
-  if (frame_) {
-    frame_->OnFocused();
-  }
-}
-
 void CefRenderFrameObserver::FocusedElementChanged(
     const blink::WebElement& element) {
   if (!frame_)

libcef/renderer/render_frame_observer.h

@@ -33,7 +33,6 @@ class CefRenderFrameObserver : public content::RenderFrameObserver {
   void DidFailProvisionalLoad() override;
   void DidFinishLoad() override;
   void FrameDetached() override;
-  void FrameFocused() override;
   void FocusedElementChanged(const blink::WebElement& element) override;
   void DraggableRegionsChanged() override;
   void DidCreateScriptContext(v8::Handle<v8::Context> context,

libcef/renderer/render_message_filter.cc

@@ -1,75 +0,0 @@
-/// Copyright (c) 2012 The Chromium Embedded Framework Authors.
-// Portions (c) 2011 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 "libcef/renderer/render_message_filter.h"
-
-#include "libcef/common/cef_messages.h"
-#include "libcef/renderer/thread_util.h"
-
-#include "base/bind.h"
-#include "base/message_loop/message_loop.h"
-#include "base/task/post_task.h"
-#include "chrome/common/render_messages.h"
-#include "content/public/browser/browser_task_traits.h"
-#include "content/public/browser/browser_thread.h"
-#include "third_party/blink/public/platform/web_string.h"
-#include "third_party/blink/public/web/web_security_policy.h"
-#include "url/gurl.h"
-#include "url/url_util.h"
-
-using content::BrowserThread;
-
-CefRenderMessageFilter::CefRenderMessageFilter() : channel_(nullptr) {}
-
-CefRenderMessageFilter::~CefRenderMessageFilter() {}
-
-void CefRenderMessageFilter::OnFilterAdded(IPC::Channel* channel) {
-  channel_ = channel;
-}
-
-void CefRenderMessageFilter::OnFilterRemoved() {
-  channel_ = nullptr;
-}
-
-bool CefRenderMessageFilter::OnMessageReceived(const IPC::Message& message) {
-  bool handled = true;
-  IPC_BEGIN_MESSAGE_MAP(CefRenderMessageFilter, message)
-    IPC_MESSAGE_HANDLER(ChromeViewHostMsg_IsCrashReportingEnabled,
-                        OnIsCrashReportingEnabled)
-    IPC_MESSAGE_UNHANDLED(handled = false)
-  IPC_END_MESSAGE_MAP()
-  return handled;
-}
-
-// Based on BrowserMessageFilter::Send.
-bool CefRenderMessageFilter::Send(IPC::Message* message) {
-  if (message->is_sync()) {
-    // We don't support sending synchronous messages from the browser.  If we
-    // really needed it, we can make this class derive from SyncMessageFilter
-    // but it seems better to not allow sending synchronous messages from the
-    // browser, since it might allow a corrupt/malicious renderer to hang us.
-    NOTREACHED() << "Can't send sync message through CefRenderMessageFilter!";
-    return false;
-  }
-
-  if (!BrowserThread::CurrentlyOn(BrowserThread::IO)) {
-    base::PostTask(FROM_HERE, {content::BrowserThread::IO},
-                   base::Bind(base::IgnoreResult(&CefRenderMessageFilter::Send),
-                              this, message));
-    return true;
-  }
-
-  if (channel_)
-    return channel_->Send(message);
-
-  delete message;
-  return false;
-}
-
-void CefRenderMessageFilter::OnIsCrashReportingEnabled(bool* enabled) {
-  // TODO(cef): Explore whether it's useful for CEF clients to report when crash
-  // reporting is enabled.
-  *enabled = false;
-}

libcef/renderer/render_message_filter.h

@@ -1,38 +0,0 @@
-// Copyright (c) 2012 The Chromium Embedded Framework Authors.
-// Portions copyright (c) 2011 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.
-
-#ifndef CEF_LIBCEF_RENDERER_RENDER_MESSAGE_FILTER_H_
-#define CEF_LIBCEF_RENDERER_RENDER_MESSAGE_FILTER_H_
-
-#include <stdint.h>
-
-#include <string>
-
-#include "ipc/ipc_channel_proxy.h"
-#include "ipc/message_filter.h"
-
-// This class sends and receives control messages on the renderer process.
-class CefRenderMessageFilter : public IPC::MessageFilter {
- public:
-  CefRenderMessageFilter();
-  ~CefRenderMessageFilter() override;
-
-  // IPC::ChannelProxy::MessageFilter implementation.
-  void OnFilterAdded(IPC::Channel* channel) override;
-  void OnFilterRemoved() override;
-  bool OnMessageReceived(const IPC::Message& message) override;
-
-  bool Send(IPC::Message* message);
-
- private:
-  // Message handlers called on the IO thread.
-  void OnIsCrashReportingEnabled(bool* enabled);
-
-  IPC::Channel* channel_;
-
-  DISALLOW_COPY_AND_ASSIGN(CefRenderMessageFilter);
-};
-
-#endif  // CEF_LIBCEF_RENDERER_RENDER_MESSAGE_FILTER_H_

libcef/renderer/render_thread_observer.cc

@@ -10,14 +10,11 @@
 #include "libcef/renderer/blink_glue.h"
 #include "libcef/renderer/content_renderer_client.h"
 
-#include "components/visitedlink/renderer/visitedlink_slave.h"
+#include "components/visitedlink/renderer/visitedlink_reader.h"
 #include "content/public/child/child_thread.h"
-#include "content/public/common/service_manager_connection.h"
-#include "content/public/common/simple_connection_filter.h"
 #include "content/public/renderer/render_thread.h"
 #include "mojo/public/cpp/bindings/strong_binding.h"
 #include "net/base/net_module.h"
-#include "services/service_manager/public/cpp/binder_registry.h"
 #include "services/service_manager/public/cpp/connector.h"
 #include "third_party/blink/public/common/associated_interfaces/associated_interface_registry.h"
 #include "third_party/blink/public/platform/web_string.h"
@@ -35,19 +32,8 @@ chrome::mojom::DynamicParams* GetDynamicConfigParams() {
 
 bool CefRenderThreadObserver::is_incognito_process_ = false;
 
-CefRenderThreadObserver::CefRenderThreadObserver()
-    : visited_link_slave_(new visitedlink::VisitedLinkSlave) {
+CefRenderThreadObserver::CefRenderThreadObserver() {
   net::NetModule::SetResourceProvider(NetResourceProvider);
-
-  auto registry = std::make_unique<service_manager::BinderRegistry>();
-  registry->AddInterface(visited_link_slave_->GetBindCallback(),
-                         base::ThreadTaskRunnerHandle::Get());
-  if (content::ChildThread::Get()) {
-    content::ChildThread::Get()
-        ->GetServiceManagerConnection()
-        ->AddConnectionFilter(std::make_unique<content::SimpleConnectionFilter>(
-            std::move(registry)));
-  }
 }
 
 CefRenderThreadObserver::~CefRenderThreadObserver() {}

libcef/renderer/render_thread_observer.h

@@ -15,10 +15,6 @@
 #include "mojo/public/cpp/bindings/associated_binding_set.h"
 #include "mojo/public/cpp/bindings/associated_receiver_set.h"
 
-namespace visitedlink {
-class VisitedLinkSlave;
-}
-
 struct Cef_CrossOriginWhiteListEntry_Params;
 
 // This class sends and receives control messages in the renderer process.
@@ -34,10 +30,6 @@ class CefRenderThreadObserver : public content::RenderThreadObserver,
   // render process is running.
   static const chrome::mojom::DynamicParams& GetDynamicParams();
 
-  visitedlink::VisitedLinkSlave* visited_link_slave() {
-    return visited_link_slave_.get();
-  }
-
  private:
   // content::RenderThreadObserver:
   bool OnControlMessageReceived(const IPC::Message& message) override;
@@ -69,8 +61,6 @@ class CefRenderThreadObserver : public content::RenderThreadObserver,
 
   static bool is_incognito_process_;
 
-  std::unique_ptr<visitedlink::VisitedLinkSlave> visited_link_slave_;
-
   mojo::AssociatedReceiverSet<chrome::mojom::RendererConfiguration>
       renderer_configuration_receivers_;
 

libcef/renderer/v8_impl.cc

@@ -2238,7 +2238,7 @@ int CefV8ValueImpl::GetArrayLength() {
 
 CefRefPtr<CefV8ArrayBufferReleaseCallback>
 CefV8ValueImpl::GetArrayBufferReleaseCallback() {
-  CEF_V8_REQUIRE_OBJECT_RETURN(0);
+  CEF_V8_REQUIRE_OBJECT_RETURN(nullptr);
 
   v8::Isolate* isolate = handle_->isolate();
   v8::HandleScope handle_scope(isolate);
@@ -2364,7 +2364,7 @@ CefRefPtr<CefV8Value> CefV8ValueImpl::ExecuteFunctionWithContext(
   v8::Local<v8::Value> value = handle_->GetNewV8Handle(false);
   if (!value->IsFunction()) {
     NOTREACHED() << "V8 value is not a function";
-    return 0;
+    return nullptr;
   }
 
   if (context.get() && !context->IsValid()) {