Update to Chromium revision 2b3ae3b8 (#394939)

libcef/renderer/content_renderer_client.cc

@@ -32,7 +32,7 @@
 #include "libcef/renderer/plugins/plugin_preroller.h"
 #include "libcef/renderer/render_frame_observer.h"
 #include "libcef/renderer/render_message_filter.h"
-#include "libcef/renderer/render_process_observer.h"
+#include "libcef/renderer/render_thread_observer.h"
 #include "libcef/renderer/thread_util.h"
 #include "libcef/renderer/v8_impl.h"
 #include "libcef/renderer/webkit_glue.h"
@@ -60,7 +60,7 @@
 #include "components/nacl/common/nacl_constants.h"
 #include "components/printing/renderer/print_web_view_helper.h"
 #include "components/visitedlink/renderer/visitedlink_slave.h"
-#include "components/web_cache/renderer/web_cache_render_process_observer.h"
+#include "components/web_cache/renderer/web_cache_impl.h"
 #include "content/common/frame_messages.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/render_process_host.h"
@@ -389,8 +389,8 @@ void CefContentRendererClient::RenderThreadStarted() {
       base::CommandLine::ForCurrentProcess();
 
   render_task_runner_ = base::ThreadTaskRunnerHandle::Get();
-  observer_.reset(new CefRenderProcessObserver());
-  web_cache_observer_.reset(new web_cache::WebCacheRenderProcessObserver());
+  observer_.reset(new CefRenderThreadObserver());
+  web_cache_impl_.reset(new web_cache::WebCacheImpl());
 
   content::RenderThread* thread = content::RenderThread::Get();
   thread->AddObserver(observer_.get());
@@ -420,7 +420,7 @@ void CefContentRendererClient::RenderThreadStarted() {
   cross_origin_whitelist_entries_ = params.cross_origin_whitelist_entries;
 
 #if defined(OS_MACOSX)
-  if (base::mac::IsOSLionOrLater()) {
+  {
     base::ScopedCFTypeRef<CFStringRef> key(
         base::SysUTF8ToCFStringRef("NSScrollViewRubberbanding"));
     base::ScopedCFTypeRef<CFStringRef> value;
@@ -629,8 +629,8 @@ CefContentRendererClient::CreateBrowserPluginDelegate(
        render_frame, mime_type, original_url);
 }
 
-void CefContentRendererClient::AddKeySystems(
-    std::vector<media::KeySystemInfo>* key_systems) {
+void CefContentRendererClient::AddSupportedKeySystems(
+    std::vector<std::unique_ptr<::media::KeySystemProperties>>* key_systems) {
   AddCefKeySystems(key_systems);
 }
 

libcef/renderer/content_renderer_client.h

@@ -34,11 +34,11 @@ class VisitedLinkSlave;
 }
 
 namespace web_cache {
-class WebCacheRenderProcessObserver;
+class WebCacheImpl;
 }
 
 class CefGuestView;
-class CefRenderProcessObserver;
+class CefRenderThreadObserver;
 struct Cef_CrossOriginWhiteListEntry_Params;
 struct CefViewHostMsg_GetPluginInfo_Output;
 class ChromePDFPrintClient;
@@ -126,7 +126,9 @@ class CefContentRendererClient : public content::ContentRendererClient,
       content::RenderFrame* render_frame,
       const std::string& mime_type,
       const GURL& original_url) override;
-  void AddKeySystems(std::vector<media::KeySystemInfo>* key_systems) override;
+  void AddSupportedKeySystems(
+      std::vector<std::unique_ptr<::media::KeySystemProperties>>* key_systems)
+      override;
   void RunScriptsAtDocumentStart(content::RenderFrame* render_frame) override;
   void RunScriptsAtDocumentEnd(content::RenderFrame* render_frame) override;
 
@@ -150,8 +152,8 @@ class CefContentRendererClient : public content::ContentRendererClient,
   void RunSingleProcessCleanupOnUIThread();
 
   scoped_refptr<base::SequencedTaskRunner> render_task_runner_;
-  std::unique_ptr<CefRenderProcessObserver> observer_;
-  std::unique_ptr<web_cache::WebCacheRenderProcessObserver> web_cache_observer_;
+  std::unique_ptr<CefRenderThreadObserver> observer_;
+  std::unique_ptr<web_cache::WebCacheImpl> web_cache_impl_;
   std::unique_ptr<SpellCheck> spellcheck_;
   std::unique_ptr<visitedlink::VisitedLinkSlave> visited_link_slave_;
 

libcef/renderer/dom_node_impl.cc

@@ -355,8 +355,9 @@ bool CefDOMNodeImpl::SetElementAttribute(const CefString& attrName,
   }
 
   WebElement element = node_.to<blink::WebElement>();
-  return element.setAttribute(base::string16(attrName),
-                              base::string16(value));
+  element.setAttribute(base::string16(attrName),
+                       base::string16(value));
+  return true;
 }
 
 CefString CefDOMNodeImpl::GetElementInnerText() {

libcef/renderer/extensions/extensions_renderer_client.cc

@@ -6,7 +6,7 @@
 
 #include "libcef/common/cef_messages.h"
 #include "libcef/renderer/extensions/extensions_dispatcher_delegate.h"
-#include "libcef/renderer/render_process_observer.h"
+#include "libcef/renderer/render_thread_observer.h"
 
 #include "base/command_line.h"
 #include "chrome/common/extensions/extension_process_policy.h"
@@ -117,7 +117,7 @@ CefExtensionsRendererClient::~CefExtensionsRendererClient() {
 }
 
 bool CefExtensionsRendererClient::IsIncognitoProcess() const {
-  return CefRenderProcessObserver::is_incognito_process();
+  return CefRenderThreadObserver::is_incognito_process();
 }
 
 int CefExtensionsRendererClient::GetLowestIsolatedWorldId() const {

libcef/renderer/extensions/extensions_renderer_client.h

@@ -5,10 +5,10 @@
 #ifndef CEF_LIBCEF_RENDERER_EXTENSIONS_EXTENSIONS_RENDERER_CLIENT_H_
 #define CEF_LIBCEF_RENDERER_EXTENSIONS_EXTENSIONS_RENDERER_CLIENT_H_
 
+#include <memory>
 #include <string>
 
 #include "base/macros.h"
-#include "base/memory/scoped_ptr.h"
 #include "extensions/renderer/extensions_renderer_client.h"
 #include "ui/base/page_transition_types.h"
 

libcef/renderer/media/cef_key_systems.cc

@@ -11,10 +11,13 @@
 #include "base/strings/string16.h"
 #include "base/strings/string_split.h"
 #include "base/strings/utf_string_conversions.h"
-#include "components/cdm/renderer/widevine_key_systems.h"
+#include "components/cdm/renderer/widevine_key_system_properties.h"
 #include "content/public/renderer/render_thread.h"
 #include "libcef/common/cef_messages.h"
 #include "media/base/eme_constants.h"
+#include "media/base/key_system_properties.h"
+
+#include "media/media_features.h"
 
 #include "widevine_cdm_version.h" // In SHARED_INTERMEDIATE_DIR.
 
@@ -25,7 +28,7 @@
 #include "base/version.h"
 #endif
 
-using media::KeySystemInfo;
+using media::KeySystemProperties;
 using media::SupportedCodecs;
 
 #if defined(ENABLE_PEPPER_CDMS)
@@ -74,7 +77,7 @@ void GetSupportedCodecsForPepperCdm(
 }
 
 static void AddPepperBasedWidevine(
-    std::vector<KeySystemInfo>* concrete_key_systems) {
+    std::vector<std::unique_ptr<KeySystemProperties>>* concrete_key_systems) {
 #if defined(WIDEVINE_CDM_MIN_GLIBC_VERSION)
   Version glibc_version(gnu_get_libc_version());
   DCHECK(glibc_version.IsValid());
@@ -115,27 +118,31 @@ static void AddPepperBasedWidevine(
 #if defined(USE_PROPRIETARY_CODECS)
     if (codecs[i] == kCdmSupportedCodecAvc1)
       supported_codecs |= media::EME_CODEC_MP4_AVC1;
+#if BUILDFLAG(ENABLE_MP4_VP9_DEMUXING)
+    if (codecs[i] == kCdmSupportedCodecVp9)
+      supported_codecs |= media::EME_CODEC_MP4_VP9;
+#endif
 #endif  // defined(USE_PROPRIETARY_CODECS)
   }
 
-  cdm::AddWidevineWithCodecs(
+  concrete_key_systems->emplace_back(new cdm::WidevineKeySystemProperties(
       supported_codecs,
       media::EmeRobustness::SW_SECURE_CRYPTO,       // Maximum audio robustness.
       media::EmeRobustness::SW_SECURE_DECODE,       // Maximum video robustness.
       media::EmeSessionTypeSupport::NOT_SUPPORTED,  // persistent-license.
       media::EmeSessionTypeSupport::
-          NOT_SUPPORTED,                        // persistent-release-message.
-      media::EmeFeatureSupport::REQUESTABLE,    // Persistent state.
-      media::EmeFeatureSupport::NOT_SUPPORTED,  // Distinctive identifier.
-      concrete_key_systems);
+          NOT_SUPPORTED,                          // persistent-release-message.
+      media::EmeFeatureSupport::REQUESTABLE,      // Persistent state.
+      media::EmeFeatureSupport::NOT_SUPPORTED));  // Distinctive identifier.
 }
 #endif  // defined(WIDEVINE_CDM_AVAILABLE)
 #endif  // defined(ENABLE_PEPPER_CDMS)
 
-void AddCefKeySystems(std::vector<KeySystemInfo>* key_systems_info) {
+void AddCefKeySystems(
+    std::vector<std::unique_ptr<KeySystemProperties>>* key_systems_properties) {
 #if defined(ENABLE_PEPPER_CDMS)
 #if defined(WIDEVINE_CDM_AVAILABLE)
-  AddPepperBasedWidevine(key_systems_info);
+  AddPepperBasedWidevine(key_systems_properties);
 #endif  // defined(WIDEVINE_CDM_AVAILABLE)
 #endif  // defined(ENABLE_PEPPER_CDMS)
 }

libcef/renderer/media/cef_key_systems.h

@@ -5,10 +5,16 @@
 #ifndef CEF_LIBCEF_RENDERER_MEDIA_CEF_KEY_SYSTEMS_H_
 #define CEF_LIBCEF_RENDERER_MEDIA_CEF_KEY_SYSTEMS_H_
 
+#include <memory>
 #include <vector>
 
-#include "media/base/key_system_info.h"
+namespace media {
+class KeySystemProperties;
+}
 
-void AddCefKeySystems(std::vector<media::KeySystemInfo>* key_systems_info);
+// Register the key systems supported by populating |key_systems_properties|.
+void AddCefKeySystems(
+    std::vector<std::unique_ptr<media::KeySystemProperties>>*
+        key_systems_properties);
 
 #endif  // CEF_LIBCEF_RENDERER_MEDIA_CEF_KEY_SYSTEMS_H_

libcef/renderer/plugins/cef_plugin_placeholder.cc

@@ -59,7 +59,8 @@ CefPluginPlaceholder::CefPluginPlaceholder(
       status_(CefViewHostMsg_GetPluginInfo_Status::kAllowed),
       title_(title),
       has_host_(false),
-      context_menu_request_id_(0) {
+      context_menu_request_id_(0),
+      ignore_updates_(false) {
   RenderThread::Get()->AddObserver(this);
 }
 
@@ -285,6 +286,31 @@ blink::WebPlugin* CefPluginPlaceholder::CreatePlugin() {
                                       GetPluginParams(), std::move(throttler));
 }
 
+void CefPluginPlaceholder::OnLoadedRectUpdate(
+    const gfx::Rect& unobscured_rect,
+    content::RenderFrame::PeripheralContentStatus status) {
+  // If the placeholder is in the blocked state, do nothing.
+  if (ignore_updates_)
+    return;
+
+  // This should only be called once.
+  set_delayed(false);
+
+  // block tiny cross-origin - simply by not continuing the load chain.
+  if (status ==
+      content::RenderFrame::CONTENT_STATUS_ESSENTIAL_CROSS_ORIGIN_TINY) {
+    ignore_updates_ = true;
+    return;
+  }
+
+  // For essential content, powersaver can be turned off.
+  if (status != content::RenderFrame::CONTENT_STATUS_PERIPHERAL)
+    set_power_saver_enabled(false);
+
+  AllowLoading();
+  LoadPlugin();
+}
+
 gin::ObjectTemplateBuilder CefPluginPlaceholder::GetObjectTemplateBuilder(
     v8::Isolate* isolate) {
   gin::ObjectTemplateBuilder builder =

libcef/renderer/plugins/cef_plugin_placeholder.h

@@ -11,13 +11,13 @@
 #include "chrome/renderer/plugins/power_saver_info.h"
 #include "components/plugins/renderer/loadable_plugin_placeholder.h"
 #include "content/public/renderer/context_menu_client.h"
-#include "content/public/renderer/render_process_observer.h"
+#include "content/public/renderer/render_thread_observer.h"
 
 enum class CefViewHostMsg_GetPluginInfo_Status;
 
 class CefPluginPlaceholder final
     : public plugins::LoadablePluginPlaceholder,
-      public content::RenderProcessObserver,
+      public content::RenderThreadObserver,
       public content::ContextMenuClient,
       public gin::Wrappable<CefPluginPlaceholder> {
  public:
@@ -50,8 +50,11 @@ class CefPluginPlaceholder final
                        const base::string16& title);
   ~CefPluginPlaceholder() override;
 
-  // content::LoadablePluginPlaceholder method
+  // content::LoadablePluginPlaceholder overrides:
   blink::WebPlugin* CreatePlugin() override;
+  void OnLoadedRectUpdate(
+      const gfx::Rect& unobscured_rect,
+      content::RenderFrame::PeripheralContentStatus status) override;
 
   // gin::Wrappable (via PluginPlaceholder) method
   gin::ObjectTemplateBuilder GetObjectTemplateBuilder(
@@ -64,7 +67,7 @@ class CefPluginPlaceholder final
   v8::Local<v8::Value> GetV8Handle(v8::Isolate* isolate) override;
   void ShowContextMenu(const blink::WebMouseEvent&) override;
 
-  // content::RenderProcessObserver methods:
+  // content::RenderThreadObserver methods:
   void PluginListChanged() override;
 
   // content::ContextMenuClient methods:
@@ -83,6 +86,8 @@ class CefPluginPlaceholder final
   int context_menu_request_id_;  // Nonzero when request pending.
   base::string16 plugin_name_;
 
+  bool ignore_updates_;
+
   DISALLOW_COPY_AND_ASSIGN(CefPluginPlaceholder);
 };
 

libcef/renderer/render_frame_observer.cc

@@ -5,7 +5,6 @@
 
 #include "base/compiler_specific.h"
 
-#include "config.h"
 MSVC_PUSH_WARNING_LEVEL(0);
 #include "platform/ScriptForbiddenScope.h"
 MSVC_POP_WARNING();

libcef/renderer/render_thread_observer.cc

@@ -3,7 +3,7 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
-#include "libcef/renderer/render_process_observer.h"
+#include "libcef/renderer/render_thread_observer.h"
 #include "libcef/common/cef_messages.h"
 #include "libcef/common/net/net_resource_provider.h"
 #include "libcef/renderer/content_renderer_client.h"
@@ -13,19 +13,19 @@
 #include "third_party/WebKit/public/platform/WebURL.h"
 #include "third_party/WebKit/public/web/WebSecurityPolicy.h"
 
-bool CefRenderProcessObserver::is_incognito_process_ = false;
+bool CefRenderThreadObserver::is_incognito_process_ = false;
 
-CefRenderProcessObserver::CefRenderProcessObserver() {
+CefRenderThreadObserver::CefRenderThreadObserver() {
   net::NetModule::SetResourceProvider(NetResourceProvider);
 }
 
-CefRenderProcessObserver::~CefRenderProcessObserver() {
+CefRenderThreadObserver::~CefRenderThreadObserver() {
 }
 
-bool CefRenderProcessObserver::OnControlMessageReceived(
+bool CefRenderThreadObserver::OnControlMessageReceived(
     const IPC::Message& message) {
   bool handled = true;
-  IPC_BEGIN_MESSAGE_MAP(CefRenderProcessObserver, message)
+  IPC_BEGIN_MESSAGE_MAP(CefRenderThreadObserver, message)
     IPC_MESSAGE_HANDLER(CefProcessMsg_SetIsIncognitoProcess,
                         OnSetIsIncognitoProcess)
     IPC_MESSAGE_HANDLER(CefProcessMsg_ModifyCrossOriginWhitelistEntry,
@@ -37,16 +37,16 @@ bool CefRenderProcessObserver::OnControlMessageReceived(
   return handled;
 }
 
-void CefRenderProcessObserver::OnRenderProcessShutdown() {
+void CefRenderThreadObserver::OnRenderProcessShutdown() {
   CefContentRendererClient::Get()->OnRenderProcessShutdown();
 }
 
-void CefRenderProcessObserver::OnSetIsIncognitoProcess(
+void CefRenderThreadObserver::OnSetIsIncognitoProcess(
     bool is_incognito_process) {
   is_incognito_process_ = is_incognito_process;
 }
 
-void CefRenderProcessObserver::OnModifyCrossOriginWhitelistEntry(
+void CefRenderThreadObserver::OnModifyCrossOriginWhitelistEntry(
     bool add,
     const Cef_CrossOriginWhiteListEntry_Params& params) {
   GURL gurl = GURL(params.source_origin);
@@ -65,6 +65,6 @@ void CefRenderProcessObserver::OnModifyCrossOriginWhitelistEntry(
   }
 }
 
-void CefRenderProcessObserver::OnClearCrossOriginWhitelist() {
+void CefRenderThreadObserver::OnClearCrossOriginWhitelist() {
   blink::WebSecurityPolicy::resetOriginAccessWhitelists();
 }

libcef/renderer/render_thread_observer.h

@@ -3,23 +3,23 @@
 // 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_PROCESS_OBSERVER_H_
-#define CEF_LIBCEF_RENDERER_RENDER_PROCESS_OBSERVER_H_
+#ifndef CEF_LIBCEF_RENDERER_RENDER_THREAD_OBSERVER_H_
+#define CEF_LIBCEF_RENDERER_RENDER_THREAD_OBSERVER_H_
 
 #include "base/compiler_specific.h"
-#include "content/public/renderer/render_process_observer.h"
+#include "content/public/renderer/render_thread_observer.h"
 
 struct Cef_CrossOriginWhiteListEntry_Params;
 
 // This class sends and receives control messages on the renderer process.
-class CefRenderProcessObserver : public content::RenderProcessObserver {
+class CefRenderThreadObserver : public content::RenderThreadObserver {
  public:
-  CefRenderProcessObserver();
-  ~CefRenderProcessObserver() override;
+  CefRenderThreadObserver();
+  ~CefRenderThreadObserver() override;
 
   static bool is_incognito_process() { return is_incognito_process_; }
 
-  // RenderProcessObserver implementation.
+  // RenderThreadObserver implementation.
   bool OnControlMessageReceived(const IPC::Message& message) override;
   void OnRenderProcessShutdown() override;
 
@@ -33,7 +33,7 @@ class CefRenderProcessObserver : public content::RenderProcessObserver {
 
   static bool is_incognito_process_;
 
-  DISALLOW_COPY_AND_ASSIGN(CefRenderProcessObserver);
+  DISALLOW_COPY_AND_ASSIGN(CefRenderThreadObserver);
 };
 
-#endif  // CEF_LIBCEF_RENDERER_RENDER_PROCESS_OBSERVER_H_
+#endif  // CEF_LIBCEF_RENDERER_RENDER_THREAD_OBSERVER_H_

libcef/renderer/v8_impl.cc

@@ -12,7 +12,6 @@
 #include "base/command_line.h"
 #include "base/compiler_specific.h"
 
-#include "config.h"
 MSVC_PUSH_WARNING_LEVEL(0);
 #include "core/frame/Frame.h"
 #include "core/frame/LocalFrame.h"

libcef/renderer/webkit_glue.cc

@@ -17,7 +17,6 @@
 
 #include "base/compiler_specific.h"
 
-#include "config.h"
 MSVC_PUSH_WARNING_LEVEL(0);
 #include "third_party/WebKit/public/platform/WebString.h"
 #include "third_party/WebKit/public/web/WebDocument.h"