Update to Chromium revision 6e53600d (#386251)

- Remove |accept_lang| parameter from CefJSDialogHandler::OnJSDialog
  and CefFormatUrlForSecurityDisplay (see https://crbug.com/336973#c36).
- Remove remaining NPAPI-related code including functions from
  cef_web_plugin.h (see https://crbug.com/493212#c55).
- Mac: 10.7+ deployment target is now required for client applications.
- Mac: Remove CefBrowserHost::SetWindowVisibility (issue #1375). No
  replacement is required for windowed rendering. Use WasHidden for
  off-screen rendering.
- Windows: Visual Studio 2015 Update 2 is now required when building
  CEF/Chromium.

libcef/renderer/browser_impl.cc

@@ -110,14 +110,16 @@ void CefBrowserImpl::Reload() {
   CEF_REQUIRE_RT_RETURN_VOID();
 
   if (render_view()->GetWebView() && render_view()->GetWebView()->mainFrame())
-    render_view()->GetWebView()->mainFrame()->reload(false);
+    render_view()->GetWebView()->mainFrame()->reload();
 }
 
 void CefBrowserImpl::ReloadIgnoreCache() {
   CEF_REQUIRE_RT_RETURN_VOID();
 
-  if (render_view()->GetWebView() && render_view()->GetWebView()->mainFrame())
-    render_view()->GetWebView()->mainFrame()->reload(true);
+  if (render_view()->GetWebView() && render_view()->GetWebView()->mainFrame()) {
+    render_view()->GetWebView()->mainFrame()->reload(
+        blink::WebFrameLoadType::ReloadBypassingCache);
+  }
 }
 
 void CefBrowserImpl::StopLoad() {

libcef/renderer/browser_impl.h

@@ -18,7 +18,6 @@
 #include "libcef/common/tracker.h"
 #include "libcef/renderer/frame_impl.h"
 
-#include "base/memory/scoped_ptr.h"
 #include "content/public/renderer/render_view_observer.h"
 
 class GURL;
@@ -152,7 +151,7 @@ class CefBrowserImpl : public CefBrowser,
   FrameObjectMap frame_objects_;
 
   // Manages response registrations.
-  scoped_ptr<CefResponseManager> response_manager_;
+  std::unique_ptr<CefResponseManager> response_manager_;
 
   IMPLEMENT_REFCOUNTING(CefBrowserImpl);
   DISALLOW_COPY_AND_ASSIGN(CefBrowserImpl);

libcef/renderer/content_renderer_client.cc

@@ -39,6 +39,7 @@
 
 #include "base/command_line.h"
 #include "base/macros.h"
+#include "base/memory/ptr_util.h"
 #include "base/metrics/user_metrics_action.h"
 #include "base/path_service.h"
 #include "base/stl_util.h"
@@ -393,7 +394,6 @@ void CefContentRendererClient::RenderThreadStarted() {
 
   content::RenderThread* thread = content::RenderThread::Get();
   thread->AddObserver(observer_.get());
-  thread->AddObserver(web_cache_observer_.get());
   thread->GetChannel()->AddFilter(new CefRenderMessageFilter);
 
   if (!command_line->HasSwitch(switches::kDisableSpellChecking)) {
@@ -459,6 +459,8 @@ void CefContentRendererClient::RenderThreadStarted() {
 
   // Register extensions last because it will trigger WebKit initialization.
   thread->RegisterExtension(extensions_v8::LoadTimesExtension::Get());
+
+  WebKitInitialized();
 }
 
 void CefContentRendererClient::RenderFrameCreated(
@@ -477,8 +479,7 @@ void CefContentRendererClient::RenderViewCreated(
   new CefPrerendererClient(render_view);
   new printing::PrintWebViewHelper(
       render_view,
-      make_scoped_ptr<printing::PrintWebViewHelper::Delegate>(
-          new extensions::CefPrintWebViewHelperDelegate()));
+      base::WrapUnique(new extensions::CefPrintWebViewHelperDelegate()));
 
   if (extensions::ExtensionsEnabled())
     extensions_renderer_client_->RenderViewCreated(render_view);
@@ -633,6 +634,18 @@ void CefContentRendererClient::AddKeySystems(
   AddCefKeySystems(key_systems);
 }
 
+void CefContentRendererClient::RunScriptsAtDocumentStart(
+    content::RenderFrame* render_frame) {
+  if (extensions::ExtensionsEnabled())
+    extensions_renderer_client_->RunScriptsAtDocumentStart(render_frame);
+}
+
+void CefContentRendererClient::RunScriptsAtDocumentEnd(
+    content::RenderFrame* render_frame) {
+  if (extensions::ExtensionsEnabled())
+    extensions_renderer_client_->RunScriptsAtDocumentEnd(render_frame);
+}
+
 void CefContentRendererClient::WillDestroyCurrentMessageLoop() {
   base::AutoLock lock_scope(single_process_cleanup_lock_);
   single_process_cleanup_complete_ = true;
@@ -729,7 +742,7 @@ blink::WebPlugin* CefContentRendererClient::CreatePlugin(
           break;
         }
 
-        scoped_ptr<content::PluginInstanceThrottler> throttler;
+        std::unique_ptr<content::PluginInstanceThrottler> throttler;
         if (power_saver_info.power_saver_enabled) {
           throttler = content::PluginInstanceThrottler::Create();
           // PluginPreroller manages its own lifetime.
@@ -742,14 +755,6 @@ blink::WebPlugin* CefContentRendererClient::CreatePlugin(
         return render_frame->CreatePlugin(frame, info, params,
                                           std::move(throttler));
       }
-      case CefViewHostMsg_GetPluginInfo_Status::kNPAPINotSupported: {
-        content::RenderThread::Get()->RecordAction(
-            base::UserMetricsAction("Plugin_NPAPINotSupported"));
-        placeholder = create_blocked_plugin(
-            IDR_BLOCKED_PLUGIN_HTML,
-            l10n_util::GetStringUTF16(IDS_PLUGIN_NOT_SUPPORTED_METRO));
-        break;
-      }
       case CefViewHostMsg_GetPluginInfo_Status::kDisabled: {
         // Intentionally using the blocked plugin resources instead of the
         // disabled plugin resources. This provides better messaging (no link to
@@ -795,6 +800,8 @@ blink::WebPlugin* CefContentRendererClient::CreatePlugin(
             base::UserMetricsAction("Plugin_BlockedByPolicy"));
         break;
       }
+      default:
+        break;
     }
   }
   placeholder->SetStatus(status);

libcef/renderer/content_renderer_client.h

@@ -15,7 +15,6 @@
 #include "libcef/renderer/browser_impl.h"
 
 #include "base/compiler_specific.h"
-#include "base/memory/scoped_ptr.h"
 #include "base/message_loop/message_loop.h"
 #include "base/sequenced_task_runner.h"
 #include "content/public/renderer/content_renderer_client.h"
@@ -128,6 +127,8 @@ class CefContentRendererClient : public content::ContentRendererClient,
       const std::string& mime_type,
       const GURL& original_url) override;
   void AddKeySystems(std::vector<media::KeySystemInfo>* key_systems) override;
+  void RunScriptsAtDocumentStart(content::RenderFrame* render_frame) override;
+  void RunScriptsAtDocumentEnd(content::RenderFrame* render_frame) override;
 
   // MessageLoop::DestructionObserver implementation.
   void WillDestroyCurrentMessageLoop() override;
@@ -149,10 +150,10 @@ class CefContentRendererClient : public content::ContentRendererClient,
   void RunSingleProcessCleanupOnUIThread();
 
   scoped_refptr<base::SequencedTaskRunner> render_task_runner_;
-  scoped_ptr<CefRenderProcessObserver> observer_;
-  scoped_ptr<web_cache::WebCacheRenderProcessObserver> web_cache_observer_;
-  scoped_ptr<SpellCheck> spellcheck_;
-  scoped_ptr<visitedlink::VisitedLinkSlave> visited_link_slave_;
+  std::unique_ptr<CefRenderProcessObserver> observer_;
+  std::unique_ptr<web_cache::WebCacheRenderProcessObserver> web_cache_observer_;
+  std::unique_ptr<SpellCheck> spellcheck_;
+  std::unique_ptr<visitedlink::VisitedLinkSlave> visited_link_slave_;
 
   // Map of RenderView pointers to CefBrowserImpl references.
   typedef std::map<content::RenderView*, CefRefPtr<CefBrowserImpl> > BrowserMap;
@@ -166,10 +167,10 @@ class CefContentRendererClient : public content::ContentRendererClient,
   typedef std::vector<Cef_CrossOriginWhiteListEntry_Params> CrossOriginList;
   CrossOriginList cross_origin_whitelist_entries_;
 
-  scoped_ptr<ChromePDFPrintClient> pdf_print_client_;
+  std::unique_ptr<ChromePDFPrintClient> pdf_print_client_;
 
-  scoped_ptr<extensions::ExtensionsClient> extensions_client_;
-  scoped_ptr<extensions::CefExtensionsRendererClient>
+  std::unique_ptr<extensions::ExtensionsClient> extensions_client_;
+  std::unique_ptr<extensions::CefExtensionsRendererClient>
       extensions_renderer_client_;
 
   int devtools_agent_count_;

libcef/renderer/extensions/extensions_renderer_client.cc

@@ -191,6 +191,16 @@ bool CefExtensionsRendererClient::WillSendRequest(
   return false;
 }
 
+void CefExtensionsRendererClient::RunScriptsAtDocumentStart(
+    content::RenderFrame* render_frame) {
+  extension_dispatcher_->RunScriptsAtDocumentStart(render_frame);
+}
+
+void CefExtensionsRendererClient::RunScriptsAtDocumentEnd(
+    content::RenderFrame* render_frame) {
+  extension_dispatcher_->RunScriptsAtDocumentEnd(render_frame);
+}
+
 // static
 bool CefExtensionsRendererClient::ShouldFork(blink::WebLocalFrame* frame,
                                              const GURL& url,

libcef/renderer/extensions/extensions_renderer_client.h

@@ -52,6 +52,8 @@ class CefExtensionsRendererClient : public ExtensionsRendererClient {
                        ui::PageTransition transition_type,
                        const GURL& url,
                        GURL* new_url);
+  void RunScriptsAtDocumentStart(content::RenderFrame* render_frame);
+  void RunScriptsAtDocumentEnd(content::RenderFrame* render_frame);
 
   static bool ShouldFork(blink::WebLocalFrame* frame,
                          const GURL& url,
@@ -64,11 +66,11 @@ class CefExtensionsRendererClient : public ExtensionsRendererClient {
       const GURL& original_url);
 
  private:
-  scoped_ptr<extensions::DispatcherDelegate> extension_dispatcher_delegate_;
-  scoped_ptr<extensions::Dispatcher> extension_dispatcher_;
-  scoped_ptr<extensions::ExtensionsGuestViewContainerDispatcher>
+  std::unique_ptr<extensions::DispatcherDelegate> extension_dispatcher_delegate_;
+  std::unique_ptr<extensions::Dispatcher> extension_dispatcher_;
+  std::unique_ptr<extensions::ExtensionsGuestViewContainerDispatcher>
       guest_view_container_dispatcher_;
-  scoped_ptr<extensions::ResourceRequestPolicy> resource_request_policy_;
+  std::unique_ptr<extensions::ResourceRequestPolicy> resource_request_policy_;
 
   DISALLOW_COPY_AND_ASSIGN(CefExtensionsRendererClient);
 };

libcef/renderer/pepper/pepper_helper.cc

@@ -4,8 +4,11 @@
 
 #include "libcef/renderer/pepper/pepper_helper.h"
 
+#include <memory>
+
 #include "libcef/renderer/pepper/renderer_pepper_host_factory.h"
 
+#include "base/memory/ptr_util.h"
 #include "content/public/renderer/renderer_ppapi_host.h"
 #include "ppapi/host/ppapi_host.h"
 
@@ -18,6 +21,5 @@ void CefPepperHelper::DidCreatePepperPlugin(content::RendererPpapiHost* host) {
   // TODO(brettw) figure out how to hook up the host factory. It needs some
   // kind of filter-like system to allow dynamic additions.
   host->GetPpapiHost()->AddHostFactoryFilter(
-      scoped_ptr<ppapi::host::HostFactory>(
-          new CefRendererPepperHostFactory(host)));
+      base::WrapUnique(new CefRendererPepperHostFactory(host)));
 }

libcef/renderer/pepper/renderer_pepper_host_factory.cc

@@ -27,7 +27,7 @@ CefRendererPepperHostFactory::CefRendererPepperHostFactory(
 
 CefRendererPepperHostFactory::~CefRendererPepperHostFactory() {}
 
-scoped_ptr<ResourceHost> CefRendererPepperHostFactory::CreateResourceHost(
+std::unique_ptr<ResourceHost> CefRendererPepperHostFactory::CreateResourceHost(
     ppapi::host::PpapiHost* host,
     PP_Resource resource,
     PP_Instance instance,
@@ -36,24 +36,24 @@ scoped_ptr<ResourceHost> CefRendererPepperHostFactory::CreateResourceHost(
 
   // Make sure the plugin is giving us a valid instance for this resource.
   if (!host_->IsValidInstance(instance))
-    return scoped_ptr<ResourceHost>();
+    return std::unique_ptr<ResourceHost>();
 
   if (host_->GetPpapiHost()->permissions().HasPermission(
           ppapi::PERMISSION_FLASH)) {
     switch (message.type()) {
       case PpapiHostMsg_Flash_Create::ID: {
-        return scoped_ptr<ResourceHost>(
+        return std::unique_ptr<ResourceHost>(
             new PepperFlashRendererHost(host_, instance, resource));
       }
       case PpapiHostMsg_FlashFullscreen_Create::ID: {
-        return scoped_ptr<ResourceHost>(
+        return std::unique_ptr<ResourceHost>(
             new PepperFlashFullscreenHost(host_, instance, resource));
       }
       case PpapiHostMsg_FlashMenu_Create::ID: {
         ppapi::proxy::SerializedFlashMenu serialized_menu;
         if (ppapi::UnpackMessage<PpapiHostMsg_FlashMenu_Create>(
                 message, &serialized_menu)) {
-          return scoped_ptr<ResourceHost>(new PepperFlashMenuHost(
+          return std::unique_ptr<ResourceHost>(new PepperFlashMenuHost(
               host_, instance, resource, serialized_menu));
         }
         break;
@@ -74,13 +74,13 @@ scoped_ptr<ResourceHost> CefRendererPepperHostFactory::CreateResourceHost(
         PP_PrivateFontCharset charset;
         if (ppapi::UnpackMessage<PpapiHostMsg_FlashFontFile_Create>(
                 message, &description, &charset)) {
-          return scoped_ptr<ResourceHost>(new PepperFlashFontFileHost(
+          return std::unique_ptr<ResourceHost>(new PepperFlashFontFileHost(
               host_, instance, resource, description, charset));
         }
         break;
       }
       case PpapiHostMsg_FlashDRM_Create::ID:
-        return scoped_ptr<ResourceHost>(
+        return std::unique_ptr<ResourceHost>(
             new PepperFlashDRMRendererHost(host_, instance, resource));
     }
   }
@@ -89,7 +89,7 @@ scoped_ptr<ResourceHost> CefRendererPepperHostFactory::CreateResourceHost(
           ppapi::PERMISSION_PRIVATE)) {
     switch (message.type()) {
       case PpapiHostMsg_PDF_Create::ID: {
-        return scoped_ptr<ResourceHost>(
+        return std::unique_ptr<ResourceHost>(
             new pdf::PepperPDFHost(host_, instance, resource));
       }
     }
@@ -101,11 +101,11 @@ scoped_ptr<ResourceHost> CefRendererPepperHostFactory::CreateResourceHost(
   // access to the other private interfaces.
   switch (message.type()) {
     case PpapiHostMsg_UMA_Create::ID: {
-      return scoped_ptr<ResourceHost>(
+      return std::unique_ptr<ResourceHost>(
           new PepperUMAHost(host_, instance, resource));
     }
   }
 
   NOTREACHED() << "Unhandled message type: " << message.type();
-  return scoped_ptr<ResourceHost>();
+  return std::unique_ptr<ResourceHost>();
 }

libcef/renderer/pepper/renderer_pepper_host_factory.h

@@ -18,7 +18,7 @@ class CefRendererPepperHostFactory : public ppapi::host::HostFactory {
   ~CefRendererPepperHostFactory() override;
 
   // HostFactory.
-  scoped_ptr<ppapi::host::ResourceHost> CreateResourceHost(
+  std::unique_ptr<ppapi::host::ResourceHost> CreateResourceHost(
       ppapi::host::PpapiHost* host,
       PP_Resource resource,
       PP_Instance instance,

libcef/renderer/plugins/cef_plugin_placeholder.cc

@@ -269,7 +269,7 @@ void CefPluginPlaceholder::ShowContextMenu(
 }
 
 blink::WebPlugin* CefPluginPlaceholder::CreatePlugin() {
-  scoped_ptr<content::PluginInstanceThrottler> throttler;
+  std::unique_ptr<content::PluginInstanceThrottler> throttler;
   // If the plugin has already been marked essential in its placeholder form,
   // we shouldn't create a new throttler and start the process all over again.
   if (power_saver_enabled()) {

libcef/renderer/render_process_observer.cc

@@ -37,10 +37,6 @@ bool CefRenderProcessObserver::OnControlMessageReceived(
   return handled;
 }
 
-void CefRenderProcessObserver::WebKitInitialized() {
-  CefContentRendererClient::Get()->WebKitInitialized();
-}
-
 void CefRenderProcessObserver::OnRenderProcessShutdown() {
   CefContentRendererClient::Get()->OnRenderProcessShutdown();
 }

libcef/renderer/render_process_observer.h

@@ -21,7 +21,6 @@ class CefRenderProcessObserver : public content::RenderProcessObserver {
 
   // RenderProcessObserver implementation.
   bool OnControlMessageReceived(const IPC::Message& message) override;
-  void WebKitInitialized() override;
   void OnRenderProcessShutdown() override;
 
  private:

libcef/renderer/render_urlrequest_impl.cc

@@ -227,8 +227,8 @@ class CefRenderURLRequest::Context
   CefURLRequest::Status status_;
   CefURLRequest::ErrorCode error_code_;
   CefRefPtr<CefResponse> response_;
-  scoped_ptr<blink::WebURLLoader> loader_;
-  scoped_ptr<CefWebURLLoaderClient> url_client_;
+  std::unique_ptr<blink::WebURLLoader> loader_;
+  std::unique_ptr<CefWebURLLoaderClient> url_client_;
   int64_t upload_data_size_;
   bool got_upload_progress_complete_;
   int64_t download_data_received_;

libcef/renderer/v8_impl.h

@@ -193,7 +193,7 @@ class CefV8ContextImpl : public CefV8Context {
   scoped_refptr<Handle> handle_;
 
   int enter_count_;
-  scoped_ptr<v8::MicrotasksScope> microtasks_scope_;
+  std::unique_ptr<v8::MicrotasksScope> microtasks_scope_;
 
   IMPLEMENT_REFCOUNTING(CefV8ContextImpl);
   DISALLOW_COPY_AND_ASSIGN(CefV8ContextImpl);