Update to Chromium revision ff259bab (#488528)

libcef/renderer/browser_impl.cc

@@ -42,6 +42,7 @@
 #include "third_party/WebKit/public/web/WebView.h"
 
 using blink::WebFrame;
+using blink::WebLocalFrame;
 using blink::WebScriptSource;
 using blink::WebString;
 using blink::WebURL;
@@ -108,26 +109,35 @@ bool CefBrowserImpl::IsLoading() {
 void CefBrowserImpl::Reload() {
   CEF_REQUIRE_RT_RETURN_VOID();
 
-  if (render_view()->GetWebView() && render_view()->GetWebView()->MainFrame()) {
-    render_view()->GetWebView()->MainFrame()->Reload(
-        blink::WebFrameLoadType::kReload);
+  if (render_view()->GetWebView()) {
+    WebFrame* main_frame = render_view()->GetWebView()->MainFrame();
+    if (main_frame && main_frame->IsWebLocalFrame()) {
+      main_frame->ToWebLocalFrame()->Reload(blink::WebFrameLoadType::kReload);
+    }
   }
 }
 
 void CefBrowserImpl::ReloadIgnoreCache() {
   CEF_REQUIRE_RT_RETURN_VOID();
 
-  if (render_view()->GetWebView() && render_view()->GetWebView()->MainFrame()) {
-    render_view()->GetWebView()->MainFrame()->Reload(
-        blink::WebFrameLoadType::kReloadBypassingCache);
+  if (render_view()->GetWebView()) {
+    WebFrame* main_frame = render_view()->GetWebView()->MainFrame();
+    if (main_frame && main_frame->IsWebLocalFrame()) {
+      main_frame->ToWebLocalFrame()->Reload(
+          blink::WebFrameLoadType::kReloadBypassingCache);
+    }
   }
 }
 
 void CefBrowserImpl::StopLoad() {
   CEF_REQUIRE_RT_RETURN_VOID();
 
-  if (render_view()->GetWebView() && render_view()->GetWebView()->MainFrame())
-    render_view()->GetWebView()->MainFrame()->StopLoading();
+  if (render_view()->GetWebView()) {
+    WebFrame* main_frame = render_view()->GetWebView()->MainFrame();
+    if (main_frame && main_frame->IsWebLocalFrame()) {
+      main_frame->ToWebLocalFrame()->StopLoading();
+    }
+  }
 }
 
 int CefBrowserImpl::GetIdentifier() {
@@ -152,16 +162,24 @@ bool CefBrowserImpl::IsPopup() {
 bool CefBrowserImpl::HasDocument() {
   CEF_REQUIRE_RT_RETURN(false);
 
-  if (render_view()->GetWebView() && render_view()->GetWebView()->MainFrame())
-    return !render_view()->GetWebView()->MainFrame()->GetDocument().IsNull();
+  if (render_view()->GetWebView()) {
+    WebFrame* main_frame = render_view()->GetWebView()->MainFrame();
+    if (main_frame && main_frame->IsWebLocalFrame()) {
+      return !main_frame->ToWebLocalFrame()->GetDocument().IsNull();
+    }
+  }
   return false;
 }
 
 CefRefPtr<CefFrame> CefBrowserImpl::GetMainFrame() {
   CEF_REQUIRE_RT_RETURN(nullptr);
 
-  if (render_view()->GetWebView() && render_view()->GetWebView()->MainFrame())
-    return GetWebFrameImpl(render_view()->GetWebView()->MainFrame()).get();
+  if (render_view()->GetWebView()) {
+    WebFrame* main_frame = render_view()->GetWebView()->MainFrame();
+    if (main_frame && main_frame->IsWebLocalFrame()) {
+      return GetWebFrameImpl(main_frame->ToWebLocalFrame()).get();
+    }
+  }
   return nullptr;
 }
 
@@ -188,21 +206,24 @@ CefRefPtr<CefFrame> CefBrowserImpl::GetFrame(const CefString& name) {
   if (web_view) {
     const blink::WebString& frame_name = blink::WebString::FromUTF16(name);
     // Search by assigned frame name (Frame::name).
-    WebFrame* frame =
-        web_view->FindFrameByName(frame_name, web_view->MainFrame());
+    WebFrame* frame = web_view->MainFrame();
+    if (frame && frame->IsWebLocalFrame())
+      frame = frame->ToWebLocalFrame()->FindFrameByName(frame_name);
     if (!frame) {
       // Search by unique frame name (Frame::uniqueName).
       const std::string& searchname = name;
       for (WebFrame* cur_frame = web_view->MainFrame(); cur_frame;
            cur_frame = cur_frame->TraverseNext()) {
-        if (render_frame_util::GetUniqueName(cur_frame) == searchname) {
+        if (cur_frame->IsWebLocalFrame() &&
+            render_frame_util::GetUniqueName(cur_frame->ToWebLocalFrame()) ==
+                searchname) {
           frame = cur_frame;
           break;
         }
       }
     }
-    if (frame)
-      return GetWebFrameImpl(frame).get();
+    if (frame && frame->IsWebLocalFrame())
+      return GetWebFrameImpl(frame->ToWebLocalFrame()).get();
   }
 
   return nullptr;
@@ -232,7 +253,9 @@ void CefBrowserImpl::GetFrameIdentifiers(std::vector<int64>& identifiers) {
   if (render_view()->GetWebView()) {
     for (WebFrame* frame = render_view()->GetWebView()->MainFrame(); frame;
          frame = frame->TraverseNext()) {
-      identifiers.push_back(render_frame_util::GetIdentifier(frame));
+      if (frame->IsWebLocalFrame())
+        identifiers.push_back(
+            render_frame_util::GetIdentifier(frame->ToWebLocalFrame()));
     }
   }
 }
@@ -246,7 +269,9 @@ void CefBrowserImpl::GetFrameNames(std::vector<CefString>& names) {
   if (render_view()->GetWebView()) {
     for (WebFrame* frame = render_view()->GetWebView()->MainFrame(); frame;
          frame = frame->TraverseNext()) {
-      names.push_back(render_frame_util::GetUniqueName(frame));
+      if (frame->IsWebLocalFrame())
+        names.push_back(
+            render_frame_util::GetUniqueName(frame->ToWebLocalFrame()));
     }
   }
 }
@@ -285,7 +310,7 @@ void CefBrowserImpl::LoadRequest(const CefMsg_LoadRequest_Params& params) {
   if (!framePtr.get())
     return;
 
-  WebFrame* web_frame = framePtr->web_frame();
+  WebLocalFrame* web_frame = framePtr->web_frame();
 
   blink::WebURLRequest request;
   CefRequestImpl::Get(params, request);
@@ -313,7 +338,7 @@ bool CefBrowserImpl::SendProcessMessage(CefProcessId target_process,
 }
 
 CefRefPtr<CefFrameImpl> CefBrowserImpl::GetWebFrameImpl(
-    blink::WebFrame* frame) {
+    blink::WebLocalFrame* frame) {
   DCHECK(frame);
   int64_t frame_id = render_frame_util::GetIdentifier(frame);
 
@@ -325,10 +350,12 @@ CefRefPtr<CefFrameImpl> CefBrowserImpl::GetWebFrameImpl(
   CefRefPtr<CefFrameImpl> framePtr(new CefFrameImpl(this, frame));
   frames_.insert(std::make_pair(frame_id, framePtr));
 
-  const int64_t parent_id =
-      frame->Parent() == NULL
-          ? webkit_glue::kInvalidFrameId
-          : render_frame_util::GetIdentifier(frame->Parent());
+  const int64_t parent_id = frame->Parent() == NULL
+                                ? webkit_glue::kInvalidFrameId
+                                : frame->Parent()->IsWebLocalFrame()
+                                      ? render_frame_util::GetIdentifier(
+                                            frame->Parent()->ToWebLocalFrame())
+                                      : webkit_glue::kInvalidFrameId;
   const base::string16& name =
       base::UTF8ToUTF16(render_frame_util::GetUniqueName(frame));
 
@@ -340,8 +367,12 @@ CefRefPtr<CefFrameImpl> CefBrowserImpl::GetWebFrameImpl(
 
 CefRefPtr<CefFrameImpl> CefBrowserImpl::GetWebFrameImpl(int64_t frame_id) {
   if (frame_id == webkit_glue::kInvalidFrameId) {
-    if (render_view()->GetWebView() && render_view()->GetWebView()->MainFrame())
-      return GetWebFrameImpl(render_view()->GetWebView()->MainFrame());
+    if (render_view()->GetWebView()) {
+      WebFrame* main_frame = render_view()->GetWebView()->MainFrame();
+      if (main_frame && main_frame->IsWebLocalFrame()) {
+        return GetWebFrameImpl(main_frame->ToWebLocalFrame());
+      }
+    }
     return nullptr;
   }
 
@@ -354,8 +385,11 @@ CefRefPtr<CefFrameImpl> CefBrowserImpl::GetWebFrameImpl(int64_t frame_id) {
     // Check if the frame exists but we don't know about it yet.
     for (WebFrame* frame = render_view()->GetWebView()->MainFrame(); frame;
          frame = frame->TraverseNext()) {
-      if (render_frame_util::GetIdentifier(frame) == frame_id)
-        return GetWebFrameImpl(frame);
+      if (frame->IsWebLocalFrame() &&
+          render_frame_util::GetIdentifier(frame->ToWebLocalFrame()) ==
+              frame_id) {
+        return GetWebFrameImpl(frame->ToWebLocalFrame());
+      }
     }
   }
 
@@ -435,7 +469,7 @@ void CefBrowserImpl::DidCommitProvisionalLoad(blink::WebLocalFrame* frame,
   OnLoadStart(frame);
 }
 
-void CefBrowserImpl::FrameDetached(WebFrame* frame) {
+void CefBrowserImpl::FrameDetached(WebLocalFrame* frame) {
   int64_t frame_id = render_frame_util::GetIdentifier(frame);
 
   if (!frames_.empty()) {
@@ -467,10 +501,13 @@ void CefBrowserImpl::FocusedNodeChanged(const blink::WebNode& node) {
         const blink::WebDocument& document = node.GetDocument();
         if (!document.IsNull()) {
           blink::WebFrame* frame = document.GetFrame();
+          if (!frame->IsWebLocalFrame())
+            return;
           CefRefPtr<CefDOMDocumentImpl> documentImpl =
-              new CefDOMDocumentImpl(this, frame);
-          handler->OnFocusedNodeChanged(this, GetWebFrameImpl(frame).get(),
-                                        documentImpl->GetOrCreateNode(node));
+              new CefDOMDocumentImpl(this, frame->ToWebLocalFrame());
+          handler->OnFocusedNodeChanged(
+              this, GetWebFrameImpl(frame->ToWebLocalFrame()).get(),
+              documentImpl->GetOrCreateNode(node));
           documentImpl->Detach();
         }
       }
@@ -479,7 +516,7 @@ void CefBrowserImpl::FocusedNodeChanged(const blink::WebNode& node) {
 }
 
 // Based on ExtensionHelper::DraggableRegionsChanged.
-void CefBrowserImpl::DraggableRegionsChanged(blink::WebFrame* frame) {
+void CefBrowserImpl::DraggableRegionsChanged(blink::WebLocalFrame* frame) {
   blink::WebVector<blink::WebDraggableRegion> webregions =
       frame->GetDocument().DraggableRegions();
   std::vector<Cef_DraggableRegion_Params> regions;
@@ -535,7 +572,7 @@ void CefBrowserImpl::OnRequest(const Cef_Request_Params& params) {
     // Execute code.
     CefRefPtr<CefFrameImpl> framePtr = GetWebFrameImpl(params.frame_id);
     if (framePtr.get()) {
-      WebFrame* web_frame = framePtr->web_frame();
+      WebLocalFrame* web_frame = framePtr->web_frame();
       if (web_frame) {
         DCHECK_EQ(params.arguments.GetSize(), (size_t)4);
 
@@ -565,7 +602,7 @@ void CefBrowserImpl::OnRequest(const Cef_Request_Params& params) {
     // Execute command.
     CefRefPtr<CefFrameImpl> framePtr = GetWebFrameImpl(params.frame_id);
     if (framePtr.get()) {
-      WebFrame* web_frame = framePtr->web_frame();
+      WebLocalFrame* web_frame = framePtr->web_frame();
       if (web_frame) {
         DCHECK_EQ(params.arguments.GetSize(), (size_t)1);
 
@@ -575,17 +612,13 @@ void CefBrowserImpl::OnRequest(const Cef_Request_Params& params) {
         DCHECK(!command.empty());
 
         if (base::LowerCaseEqualsASCII(command, "getsource")) {
-          if (web_frame->IsWebLocalFrame()) {
-            response = blink::WebFrameContentDumper::DumpAsMarkup(
-                           web_frame->ToWebLocalFrame())
-                           .Utf8();
-            success = true;
-          }
+          response =
+              blink::WebFrameContentDumper::DumpAsMarkup(web_frame).Utf8();
+          success = true;
         } else if (base::LowerCaseEqualsASCII(command, "gettext")) {
           response = webkit_glue::DumpDocumentText(web_frame);
           success = true;
-        } else if (web_frame->IsWebLocalFrame() &&
-                   web_frame->ToWebLocalFrame()->ExecuteCommand(
+        } else if (web_frame->ExecuteCommand(
                        blink::WebString::FromUTF8(command))) {
           success = true;
         }
@@ -595,7 +628,7 @@ void CefBrowserImpl::OnRequest(const Cef_Request_Params& params) {
     // Load a string.
     CefRefPtr<CefFrameImpl> framePtr = GetWebFrameImpl(params.frame_id);
     if (framePtr.get()) {
-      WebFrame* web_frame = framePtr->web_frame();
+      WebLocalFrame* web_frame = framePtr->web_frame();
       if (web_frame) {
         DCHECK_EQ(params.arguments.GetSize(), (size_t)2);
 

libcef/renderer/browser_impl.h

@@ -32,8 +32,9 @@ class ListValue;
 }
 
 namespace blink {
+class WebFrame;
 class WebNode;
-}
+}  // namespace blink
 
 // Renderer plumbing for CEF features. There is a one-to-one relationship
 // between RenderView on the renderer side and RenderViewHost on the browser
@@ -91,7 +92,7 @@ class CefBrowserImpl : public CefBrowser, public content::RenderViewObserver {
                           bool user_initiated);
 
   // Returns the matching CefFrameImpl reference or creates a new one.
-  CefRefPtr<CefFrameImpl> GetWebFrameImpl(blink::WebFrame* frame);
+  CefRefPtr<CefFrameImpl> GetWebFrameImpl(blink::WebLocalFrame* frame);
   CefRefPtr<CefFrameImpl> GetWebFrameImpl(int64_t frame_id);
 
   // Frame objects will be deleted immediately before the frame is closed.
@@ -114,14 +115,14 @@ class CefBrowserImpl : public CefBrowser, public content::RenderViewObserver {
                               const blink::WebURLError& error) override;
   void DidCommitProvisionalLoad(blink::WebLocalFrame* frame,
                                 bool is_new_navigation) override;
-  void DraggableRegionsChanged(blink::WebFrame* frame) override;
   bool OnMessageReceived(const IPC::Message& message) override;
 
   // Forwarded from CefRenderFrameObserver.
   void DidFinishLoad(blink::WebLocalFrame* frame);
   void DidStartProvisionalLoad(blink::WebLocalFrame* frame);
-  void FrameDetached(blink::WebFrame* frame);
+  void FrameDetached(blink::WebLocalFrame* frame);
   void FocusedNodeChanged(const blink::WebNode& node);
+  void DraggableRegionsChanged(blink::WebLocalFrame* frame);
 
  private:
   // RenderViewObserver::OnMessageReceived message handlers.

libcef/renderer/content_renderer_client.cc

@@ -282,8 +282,6 @@ void CefContentRendererClient::WebKitInitialized() {
         blink::WebSecurityPolicy::RegisterURLSchemeAsDisplayIsolated(scheme);
       if (info.is_secure)
         webkit_glue::RegisterURLSchemeAsSecure(scheme);
-      if (info.is_cors_enabled)
-        webkit_glue::RegisterURLSchemeAsCORSEnabled(scheme);
     }
   }
 
@@ -535,6 +533,9 @@ bool CefContentRendererClient::HandleNavigation(
     blink::WebNavigationType type,
     blink::WebNavigationPolicy default_policy,
     bool is_redirect) {
+  if (!frame->IsWebLocalFrame())
+    return false;
+
   CefRefPtr<CefApp> application = CefContentClient::Get()->application();
   if (application.get()) {
     CefRefPtr<CefRenderProcessHandler> handler =
@@ -543,7 +544,8 @@ bool CefContentRendererClient::HandleNavigation(
       CefRefPtr<CefBrowserImpl> browserPtr =
           CefBrowserImpl::GetBrowserForMainFrame(frame->Top());
       if (browserPtr.get()) {
-        CefRefPtr<CefFrameImpl> framePtr = browserPtr->GetWebFrameImpl(frame);
+        CefRefPtr<CefFrameImpl> framePtr =
+            browserPtr->GetWebFrameImpl(frame->ToWebLocalFrame());
         CefRefPtr<CefRequest> requestPtr(CefRequest::Create());
         CefRequestImpl* requestImpl =
             static_cast<CefRequestImpl*>(requestPtr.get());
@@ -611,6 +613,7 @@ bool CefContentRendererClient::WillSendRequest(
     blink::WebLocalFrame* frame,
     ui::PageTransition transition_type,
     const blink::WebURL& url,
+    std::vector<std::unique_ptr<content::URLLoaderThrottle>>* throttles,
     GURL* new_url) {
   if (extensions::ExtensionsEnabled()) {
     return extensions_renderer_client_->WillSendRequest(frame, transition_type,

libcef/renderer/content_renderer_client.h

@@ -28,7 +28,7 @@ class ExtensionsClient;
 class ExtensionsGuestViewContainerDispatcher;
 class ExtensionsRendererClient;
 class ResourceRequestPolicy;
-}
+}  // namespace extensions
 
 namespace web_cache {
 class WebCacheImpl;
@@ -110,10 +110,12 @@ class CefContentRendererClient : public content::ContentRendererClient,
                   bool is_initial_navigation,
                   bool is_server_redirect,
                   bool* send_referrer) override;
-  bool WillSendRequest(blink::WebLocalFrame* frame,
-                       ui::PageTransition transition_type,
-                       const blink::WebURL& url,
-                       GURL* new_url) override;
+  bool WillSendRequest(
+      blink::WebLocalFrame* frame,
+      ui::PageTransition transition_type,
+      const blink::WebURL& url,
+      std::vector<std::unique_ptr<content::URLLoaderThrottle>>* throttles,
+      GURL* new_url) override;
   unsigned long long VisitedLinkHash(const char* canonical_url,
                                      size_t length) override;
   bool IsLinkVisited(unsigned long long link_hash) override;

libcef/renderer/dom_document_impl.cc

@@ -11,20 +11,20 @@
 #include "third_party/WebKit/public/platform/WebURL.h"
 #include "third_party/WebKit/public/web/WebDocument.h"
 #include "third_party/WebKit/public/web/WebElement.h"
-#include "third_party/WebKit/public/web/WebFrame.h"
 #include "third_party/WebKit/public/web/WebLocalFrame.h"
 #include "third_party/WebKit/public/web/WebNode.h"
 #include "third_party/WebKit/public/web/WebRange.h"
 
 using blink::WebDocument;
 using blink::WebElement;
-using blink::WebFrame;
+using blink::WebLocalFrame;
 using blink::WebNode;
 using blink::WebRange;
 using blink::WebString;
 using blink::WebURL;
 
-CefDOMDocumentImpl::CefDOMDocumentImpl(CefBrowserImpl* browser, WebFrame* frame)
+CefDOMDocumentImpl::CefDOMDocumentImpl(CefBrowserImpl* browser,
+                                       WebLocalFrame* frame)
     : browser_(browser), frame_(frame) {
   const WebDocument& document = frame_->GetDocument();
   DCHECK(!document.IsNull());
@@ -90,21 +90,20 @@ CefRefPtr<CefDOMNode> CefDOMDocumentImpl::GetFocusedNode() {
 }
 
 bool CefDOMDocumentImpl::HasSelection() {
-  if (!VerifyContext() || !frame_->IsWebLocalFrame())
+  if (!VerifyContext())
     return false;
 
-  return frame_->ToWebLocalFrame()->HasSelection();
+  return frame_->HasSelection();
 }
 
 int CefDOMDocumentImpl::GetSelectionStartOffset() {
-  if (!VerifyContext() || !frame_->IsWebLocalFrame())
+  if (!VerifyContext())
     return 0;
 
-  blink::WebLocalFrame* local_frame = frame_->ToWebLocalFrame();
-  if (!!local_frame->HasSelection())
+  if (!frame_->HasSelection())
     return 0;
 
-  const WebRange& range = local_frame->SelectionRange();
+  const WebRange& range = frame_->SelectionRange();
   if (range.IsNull())
     return 0;
 
@@ -112,14 +111,13 @@ int CefDOMDocumentImpl::GetSelectionStartOffset() {
 }
 
 int CefDOMDocumentImpl::GetSelectionEndOffset() {
-  if (!VerifyContext() || !frame_->IsWebLocalFrame())
+  if (!VerifyContext())
     return 0;
 
-  blink::WebLocalFrame* local_frame = frame_->ToWebLocalFrame();
-  if (!!local_frame->HasSelection())
+  if (!frame_->HasSelection())
     return 0;
 
-  const WebRange& range = local_frame->SelectionRange();
+  const WebRange& range = frame_->SelectionRange();
   if (range.IsNull())
     return 0;
 
@@ -128,14 +126,13 @@ int CefDOMDocumentImpl::GetSelectionEndOffset() {
 
 CefString CefDOMDocumentImpl::GetSelectionAsMarkup() {
   CefString str;
-  if (!VerifyContext() || !frame_->IsWebLocalFrame())
+  if (!VerifyContext())
     return str;
 
-  blink::WebLocalFrame* local_frame = frame_->ToWebLocalFrame();
-  if (!!local_frame->HasSelection())
+  if (!frame_->HasSelection())
     return str;
 
-  const WebString& markup = local_frame->SelectionAsMarkup();
+  const WebString& markup = frame_->SelectionAsMarkup();
   if (!markup.IsNull())
     str = markup.Utf16();
 
@@ -144,14 +141,13 @@ CefString CefDOMDocumentImpl::GetSelectionAsMarkup() {
 
 CefString CefDOMDocumentImpl::GetSelectionAsText() {
   CefString str;
-  if (!VerifyContext() || !frame_->IsWebLocalFrame())
+  if (!VerifyContext())
     return str;
 
-  blink::WebLocalFrame* local_frame = frame_->ToWebLocalFrame();
-  if (!!local_frame->HasSelection())
+  if (!frame_->HasSelection())
     return str;
 
-  const WebString& text = local_frame->SelectionAsText();
+  const WebString& text = frame_->SelectionAsText();
   if (!text.IsNull())
     str = text.Utf16();
 

libcef/renderer/dom_document_impl.h

@@ -10,15 +10,15 @@
 #include "include/cef_dom.h"
 
 namespace blink {
-class WebFrame;
+class WebLocalFrame;
 class WebNode;
-};
+};  // namespace blink
 
 class CefBrowserImpl;
 
 class CefDOMDocumentImpl : public CefDOMDocument {
  public:
-  CefDOMDocumentImpl(CefBrowserImpl* browser, blink::WebFrame* frame);
+  CefDOMDocumentImpl(CefBrowserImpl* browser, blink::WebLocalFrame* frame);
   ~CefDOMDocumentImpl() override;
 
   // CefDOMDocument methods.
@@ -38,7 +38,7 @@ class CefDOMDocumentImpl : public CefDOMDocument {
   CefString GetCompleteURL(const CefString& partialURL) override;
 
   CefBrowserImpl* GetBrowser() { return browser_; }
-  blink::WebFrame* GetFrame() { return frame_; }
+  blink::WebLocalFrame* GetFrame() { return frame_; }
 
   // The document maintains a map of all existing node objects.
   CefRefPtr<CefDOMNode> GetOrCreateNode(const blink::WebNode& node);
@@ -52,7 +52,7 @@ class CefDOMDocumentImpl : public CefDOMDocument {
 
  protected:
   CefBrowserImpl* browser_;
-  blink::WebFrame* frame_;
+  blink::WebLocalFrame* frame_;
 
   typedef std::map<blink::WebNode, CefDOMNode*> NodeMap;
   NodeMap node_map_;

libcef/renderer/dom_node_impl.cc

@@ -18,7 +18,6 @@
 #include "third_party/WebKit/public/web/WebDocument.h"
 #include "third_party/WebKit/public/web/WebElement.h"
 #include "third_party/WebKit/public/web/WebFormControlElement.h"
-#include "third_party/WebKit/public/web/WebFrame.h"
 #include "third_party/WebKit/public/web/WebInputElement.h"
 #include "third_party/WebKit/public/web/WebNode.h"
 #include "third_party/WebKit/public/web/WebSelectElement.h"
@@ -26,7 +25,6 @@
 using blink::WebDocument;
 using blink::WebDOMEvent;
 using blink::WebElement;
-using blink::WebFrame;
 using blink::WebFormControlElement;
 using blink::WebInputElement;
 using blink::WebNode;

libcef/renderer/extensions/extensions_renderer_client.cc

@@ -117,6 +117,20 @@ int CefExtensionsRendererClient::GetLowestIsolatedWorldId() const {
   return 1;
 }
 
+extensions::Dispatcher* CefExtensionsRendererClient::GetDispatcher() {
+  return extension_dispatcher_.get();
+}
+
+void CefExtensionsRendererClient::OnExtensionLoaded(
+    const extensions::Extension& extension) {
+  resource_request_policy_->OnExtensionLoaded(extension);
+}
+
+void CefExtensionsRendererClient::OnExtensionUnloaded(
+    const extensions::ExtensionId& extension_id) {
+  resource_request_policy_->OnExtensionUnloaded(extension_id);
+}
+
 void CefExtensionsRendererClient::RenderThreadStarted() {
   content::RenderThread* thread = content::RenderThread::Get();
 

libcef/renderer/extensions/extensions_renderer_client.h

@@ -19,13 +19,13 @@ class WebFrame;
 class WebLocalFrame;
 struct WebPluginParams;
 class WebURL;
-}
+}  // namespace blink
 
 namespace content {
 class BrowserPluginDelegate;
 class RenderFrame;
 class RenderView;
-}
+}  // namespace content
 
 namespace extensions {
 
@@ -42,6 +42,10 @@ class CefExtensionsRendererClient : public ExtensionsRendererClient {
   // ExtensionsRendererClient implementation.
   bool IsIncognitoProcess() const override;
   int GetLowestIsolatedWorldId() const override;
+  extensions::Dispatcher* GetDispatcher() override;
+  void OnExtensionLoaded(const extensions::Extension& extension) override;
+  void OnExtensionUnloaded(
+      const extensions::ExtensionId& extension_id) override;
 
   // See CefContentRendererClient methods with the same names.
   void RenderThreadStarted();

libcef/renderer/frame_impl.cc

@@ -26,7 +26,6 @@
 #include "third_party/WebKit/public/platform/WebString.h"
 #include "third_party/WebKit/public/platform/WebURL.h"
 #include "third_party/WebKit/public/web/WebDocument.h"
-#include "third_party/WebKit/public/web/WebFrame.h"
 #include "third_party/WebKit/public/web/WebFrameContentDumper.h"
 #include "third_party/WebKit/public/web/WebKit.h"
 #include "third_party/WebKit/public/web/WebLocalFrame.h"
@@ -35,7 +34,7 @@
 
 using blink::WebString;
 
-CefFrameImpl::CefFrameImpl(CefBrowserImpl* browser, blink::WebFrame* frame)
+CefFrameImpl::CefFrameImpl(CefBrowserImpl* browser, blink::WebLocalFrame* frame)
     : browser_(browser),
       frame_(frame),
       frame_id_(render_frame_util::GetIdentifier(frame)) {}
@@ -82,10 +81,9 @@ void CefFrameImpl::ViewSource() {
 
 void CefFrameImpl::GetSource(CefRefPtr<CefStringVisitor> visitor) {
   CEF_REQUIRE_RT_RETURN_VOID();
-  if (frame_ && frame_->IsWebLocalFrame()) {
-    const CefString& content = std::string(
-        blink::WebFrameContentDumper::DumpAsMarkup(frame_->ToWebLocalFrame())
-            .Utf8());
+  if (frame_) {
+    const CefString& content =
+        std::string(blink::WebFrameContentDumper::DumpAsMarkup(frame_).Utf8());
     visitor->Visit(content);
   }
 }
@@ -205,8 +203,8 @@ CefRefPtr<CefFrame> CefFrameImpl::GetParent() {
 
   if (frame_) {
     blink::WebFrame* parent = frame_->Parent();
-    if (parent)
-      return browser_->GetWebFrameImpl(parent).get();
+    if (parent && parent->IsWebLocalFrame())
+      return browser_->GetWebFrameImpl(parent->ToWebLocalFrame()).get();
   }
 
   return NULL;
@@ -267,8 +265,8 @@ void CefFrameImpl::Detach() {
 
 void CefFrameImpl::ExecuteCommand(const std::string& command) {
   CEF_REQUIRE_RT_RETURN_VOID();
-  if (frame_ && frame_->IsWebLocalFrame())
-    frame_->ToWebLocalFrame()->ExecuteCommand(WebString::FromUTF8(command));
+  if (frame_)
+    frame_->ExecuteCommand(WebString::FromUTF8(command));
 }
 
 // Enable deprecation warnings for MSVC. See http://crbug.com/585142.

libcef/renderer/frame_impl.h

@@ -13,7 +13,7 @@
 class CefBrowserImpl;
 
 namespace blink {
-class WebFrame;
+class WebLocalFrame;
 }
 
 // Implementation of CefFrame. CefFrameImpl objects are owned by the
@@ -21,7 +21,7 @@ class WebFrame;
 // associated renderer WebFrame will close.
 class CefFrameImpl : public CefFrame {
  public:
-  CefFrameImpl(CefBrowserImpl* browser, blink::WebFrame* frame);
+  CefFrameImpl(CefBrowserImpl* browser, blink::WebLocalFrame* frame);
   ~CefFrameImpl() override;
 
   // CefFrame implementation.
@@ -54,13 +54,13 @@ class CefFrameImpl : public CefFrame {
 
   void Detach();
 
-  blink::WebFrame* web_frame() const { return frame_; }
+  blink::WebLocalFrame* web_frame() const { return frame_; }
 
  private:
   void ExecuteCommand(const std::string& command);
 
   CefBrowserImpl* browser_;
-  blink::WebFrame* frame_;
+  blink::WebLocalFrame* frame_;
   int64 frame_id_;
 
   IMPLEMENT_REFCOUNTING(CefFrameImpl);

libcef/renderer/plugins/cef_plugin_placeholder.cc

@@ -169,7 +169,10 @@ void CefPluginPlaceholder::PluginListChanged() {
   if (!render_frame() || !plugin())
     return;
   blink::WebLocalFrame* web_frame = render_frame()->GetWebFrame();
-  blink::WebDocument document = web_frame->Top()->GetDocument();
+  if (!web_frame->Top()->IsWebLocalFrame())
+    return;
+  blink::WebDocument document =
+      web_frame->Top()->ToWebLocalFrame()->GetDocument();
   if (document.IsNull())
     return;
 

libcef/renderer/render_frame_observer.cc

@@ -73,6 +73,16 @@ void CefRenderFrameObserver::FocusedNodeChanged(const blink::WebNode& node) {
   browserPtr->FocusedNodeChanged(node);
 }
 
+void CefRenderFrameObserver::DraggableRegionsChanged() {
+  blink::WebLocalFrame* frame = render_frame()->GetWebFrame();
+  CefRefPtr<CefBrowserImpl> browserPtr =
+      CefBrowserImpl::GetBrowserForMainFrame(frame->Top());
+  if (!browserPtr.get())
+    return;
+
+  browserPtr->DraggableRegionsChanged(frame);
+}
+
 void CefRenderFrameObserver::DidCreateScriptContext(
     v8::Handle<v8::Context> context,
     int world_id) {

libcef/renderer/render_frame_observer.h

@@ -22,6 +22,7 @@ class CefRenderFrameObserver : public content::RenderFrameObserver {
   void FrameDetached() override;
   void FrameFocused() override;
   void FocusedNodeChanged(const blink::WebNode& node) override;
+  void DraggableRegionsChanged() override;
   void DidCreateScriptContext(v8::Handle<v8::Context> context,
                               int world_id) override;
   void WillReleaseScriptContext(v8::Handle<v8::Context> context,

libcef/renderer/render_frame_util.cc

@@ -12,7 +12,7 @@
 
 namespace render_frame_util {
 
-int64_t GetIdentifier(blink::WebFrame* frame) {
+int64_t GetIdentifier(blink::WebLocalFrame* frame) {
   // Each WebFrame will have an associated RenderFrame. The RenderFrame
   // routing IDs are unique within a given renderer process.
   content::RenderFrame* render_frame =
@@ -23,7 +23,7 @@ int64_t GetIdentifier(blink::WebFrame* frame) {
   return webkit_glue::kInvalidFrameId;
 }
 
-std::string GetUniqueName(blink::WebFrame* frame) {
+std::string GetUniqueName(blink::WebLocalFrame* frame) {
   content::RenderFrameImpl* render_frame =
       content::RenderFrameImpl::FromWebFrame(frame);
   DCHECK(render_frame);
@@ -32,4 +32,4 @@ std::string GetUniqueName(blink::WebFrame* frame) {
   return std::string();
 }
 
-}  // render_frame_util
+}  // namespace render_frame_util

libcef/renderer/render_frame_util.h

@@ -11,14 +11,14 @@
 #include <string>
 
 namespace blink {
-class WebFrame;
+class WebLocalFrame;
 }
 
 namespace render_frame_util {
 
-int64_t GetIdentifier(blink::WebFrame* frame);
-std::string GetUniqueName(blink::WebFrame* frame);
+int64_t GetIdentifier(blink::WebLocalFrame* frame);
+std::string GetUniqueName(blink::WebLocalFrame* frame);
 
-}  // render_frame_util
+}  // namespace render_frame_util
 
 #endif  // CEF_LIBCEF_RENDERER_RENDER_FRAME_UTIL_H_

libcef/renderer/render_urlrequest_impl.cc

@@ -94,13 +94,19 @@ class CefRenderURLRequest::Context
     if (!url.is_valid())
       return false;
 
-    loader_ = blink::Platform::Current()->CreateURLLoader();
     url_client_.reset(new CefWebURLLoaderClient(this, request_->GetFlags()));
 
     WebURLRequest urlRequest;
     static_cast<CefRequestImpl*>(request_.get())
         ->Get(urlRequest, upload_data_size_);
 
+    // Set the origin to match the request. The requirement for an origin is
+    // DCHECK'd in ResourceDispatcherHostImpl::ContinuePendingBeginRequest.
+    urlRequest.SetRequestorOrigin(
+        blink::WebSecurityOrigin::Create(urlRequest.Url()));
+
+    loader_ = blink::Platform::Current()->CreateURLLoader(urlRequest,
+                                                          task_runner_.get());
     loader_->LoadAsynchronously(urlRequest, url_client_.get());
     return true;
   }
@@ -211,7 +217,7 @@ class CefRenderURLRequest::Context
   CefRefPtr<CefRenderURLRequest> url_request_;
   CefRefPtr<CefRequest> request_;
   CefRefPtr<CefURLRequestClient> client_;
-  scoped_refptr<base::SequencedTaskRunner> task_runner_;
+  scoped_refptr<base::SingleThreadTaskRunner> task_runner_;
   CefURLRequest::Status status_;
   CefURLRequest::ErrorCode error_code_;
   CefRefPtr<CefResponse> response_;

libcef/renderer/v8_impl.cc

@@ -883,7 +883,7 @@ CefRefPtr<CefBrowser> CefV8ContextImpl::GetBrowser() {
   CefRefPtr<CefBrowser> browser;
   CEF_V8_REQUIRE_VALID_HANDLE_RETURN(browser);
 
-  blink::WebFrame* webframe = GetWebFrame();
+  blink::WebLocalFrame* webframe = GetWebFrame();
   if (webframe)
     browser = CefBrowserImpl::GetBrowserForMainFrame(webframe->Top());
 
@@ -894,7 +894,7 @@ CefRefPtr<CefFrame> CefV8ContextImpl::GetFrame() {
   CefRefPtr<CefFrame> frame;
   CEF_V8_REQUIRE_VALID_HANDLE_RETURN(frame);
 
-  blink::WebFrame* webframe = GetWebFrame();
+  blink::WebLocalFrame* webframe = GetWebFrame();
   if (webframe) {
     CefRefPtr<CefBrowserImpl> browser =
         CefBrowserImpl::GetBrowserForMainFrame(webframe->Top());
@@ -1023,7 +1023,7 @@ v8::Local<v8::Context> CefV8ContextImpl::GetV8Context() {
   return handle_->GetNewV8Handle();
 }
 
-blink::WebFrame* CefV8ContextImpl::GetWebFrame() {
+blink::WebLocalFrame* CefV8ContextImpl::GetWebFrame() {
   CEF_REQUIRE_RT();
 
   if (webkit_glue::IsScriptForbidden())

libcef/renderer/v8_impl.h

@@ -21,7 +21,7 @@ class CefTrackNode;
 class GURL;
 
 namespace blink {
-class WebFrame;
+class WebLocalFrame;
 };
 
 // Call after a V8 Isolate has been created and entered for the first time.
@@ -177,7 +177,7 @@ class CefV8ContextImpl : public CefV8Context {
             CefRefPtr<CefV8Exception>& exception) override;
 
   v8::Local<v8::Context> GetV8Context();
-  blink::WebFrame* GetWebFrame();
+  blink::WebLocalFrame* GetWebFrame();
 
  private:
   typedef CefV8Handle<v8::Context> Handle;

libcef/renderer/webkit_glue.cc

@@ -66,7 +66,7 @@ void GoForward(blink::WebView* view) {
     impl->Client()->NavigateBackForwardSoon(1);
 }
 
-std::string DumpDocumentText(blink::WebFrame* frame) {
+std::string DumpDocumentText(blink::WebLocalFrame* frame) {
   // We use the document element's text instead of the body text here because
   // not all documents have a body, such as XML documents.
   blink::WebElement document_element = frame->GetDocument().DocumentElement();
@@ -201,10 +201,6 @@ void RegisterURLSchemeAsSecure(const blink::WebString& scheme) {
   blink::SchemeRegistry::RegisterURLSchemeAsSecure(scheme);
 }
 
-void RegisterURLSchemeAsCORSEnabled(const blink::WebString& scheme) {
-  blink::SchemeRegistry::RegisterURLSchemeAsCORSEnabled(scheme);
-}
-
 struct CefScriptForbiddenScope::Impl {
   blink::ScriptForbiddenScope scope_;
 };
@@ -213,4 +209,4 @@ CefScriptForbiddenScope::CefScriptForbiddenScope() : impl_(new Impl()) {}
 
 CefScriptForbiddenScope::~CefScriptForbiddenScope() {}
 
-}  // webkit_glue
+}  // namespace webkit_glue

libcef/renderer/webkit_glue.h

@@ -19,11 +19,11 @@
 
 namespace blink {
 class WebElement;
-class WebFrame;
+class WebLocalFrame;
 class WebNode;
 class WebString;
 class WebView;
-}
+}  // namespace blink
 
 namespace webkit_glue {
 
@@ -35,7 +35,7 @@ BLINK_EXPORT void GoBack(blink::WebView* view);
 BLINK_EXPORT void GoForward(blink::WebView* view);
 
 // Returns the text of the document element.
-BLINK_EXPORT std::string DumpDocumentText(blink::WebFrame* frame);
+BLINK_EXPORT std::string DumpDocumentText(blink::WebLocalFrame* frame);
 
 // Expose additional actions on WebNode.
 BLINK_EXPORT cef_dom_node_type_t GetNodeType(const blink::WebNode& node);
@@ -67,8 +67,6 @@ BLINK_EXPORT bool IsScriptForbidden();
 
 BLINK_EXPORT void RegisterURLSchemeAsLocal(const blink::WebString& scheme);
 BLINK_EXPORT void RegisterURLSchemeAsSecure(const blink::WebString& scheme);
-BLINK_EXPORT void RegisterURLSchemeAsCORSEnabled(
-    const blink::WebString& scheme);
 
 // Wrapper for blink::ScriptForbiddenScope.
 class BLINK_EXPORT CefScriptForbiddenScope final {
@@ -83,6 +81,6 @@ class BLINK_EXPORT CefScriptForbiddenScope final {
   DISALLOW_COPY_AND_ASSIGN(CefScriptForbiddenScope);
 };
 
-}  // webkit_glue
+}  // namespace webkit_glue
 
 #endif  // CEF_LIBCEF_RENDERER_WEBKIT_GLUE_H_