Update to Chromium revision 261035.

- The CefSettings.release_dcheck_enabled option has been removed. This functionality can be enabled by setting the dcheck_always_on=1 gyp variable before building CEF/Chromium. See http://crbug.com/350462 for details.
- The UR_FLAG_ALLOW_COOKIES option has been removed and the functionality has been merged into UR_FLAG_ALLOW_CACHED_CREDENTIALS.
- Mac: [NSApplication sharedApplication] should no longer be called in the renderer process. See http://crbug.com/306348 for details.

git-svn-id: https://chromiumembedded.googlecode.com/svn/trunk@1641 5089003a-bbd8-11dd-ad1f-f1f9622dbc98

libcef/renderer/browser_impl.cc

@@ -46,8 +46,6 @@ using blink::WebView;
 
 namespace {
 
-const int64 kInvalidFrameId = -1;
-
 blink::WebString FilePathStringToWebString(
     const base::FilePath::StringType& str) {
 #if defined(OS_POSIX)
@@ -228,7 +226,7 @@ void CefBrowserImpl::GetFrameIdentifiers(std::vector<int64>& identifiers) {
     if (main_frame) {
       WebFrame* cur = main_frame;
       do {
-        identifiers.push_back(cur->identifier());
+        identifiers.push_back(webkit_glue::GetIdentifier(cur));
         cur = cur->traverseNext(true);
       } while (cur != main_frame);
     }
@@ -275,7 +273,7 @@ CefBrowserImpl::CefBrowserImpl(content::RenderView* render_view,
       browser_id_(browser_id),
       is_popup_(is_popup),
       is_window_rendering_disabled_(is_window_rendering_disabled),
-      last_focused_frame_id_(kInvalidFrameId) {
+      last_focused_frame_id_(webkit_glue::kInvalidFrameId) {
   response_manager_.reset(new CefResponseManager);
 }
 
@@ -380,7 +378,7 @@ bool CefBrowserImpl::SendProcessMessage(CefProcessId target_process,
 CefRefPtr<CefFrameImpl> CefBrowserImpl::GetWebFrameImpl(
     blink::WebFrame* frame) {
   DCHECK(frame);
-  int64 frame_id = frame->identifier();
+  int64 frame_id = webkit_glue::GetIdentifier(frame);
 
   // Frames are re-used between page loads. Only add the frame to the map once.
   FrameMap::const_iterator it = frames_.find(frame_id);
@@ -391,7 +389,7 @@ CefRefPtr<CefFrameImpl> CefBrowserImpl::GetWebFrameImpl(
   frames_.insert(std::make_pair(frame_id, framePtr));
 
   int64 parent_id = frame->parent() == NULL ?
-      kInvalidFrameId : frame->parent()->identifier();
+      webkit_glue::kInvalidFrameId : webkit_glue::GetIdentifier(frame->parent());
   base::string16 name = frame->uniqueName();
 
   // Notify the browser that the frame has been identified.
@@ -401,7 +399,7 @@ CefRefPtr<CefFrameImpl> CefBrowserImpl::GetWebFrameImpl(
 }
 
 CefRefPtr<CefFrameImpl> CefBrowserImpl::GetWebFrameImpl(int64 frame_id) {
-  if (frame_id == kInvalidFrameId) {
+  if (frame_id == webkit_glue::kInvalidFrameId) {
     if (render_view()->GetWebView() && render_view()->GetWebView()->mainFrame())
       return GetWebFrameImpl(render_view()->GetWebView()->mainFrame());
     return NULL;
@@ -418,7 +416,7 @@ CefRefPtr<CefFrameImpl> CefBrowserImpl::GetWebFrameImpl(int64 frame_id) {
     if (main_frame) {
       WebFrame* cur = main_frame;
       do {
-        if (cur->identifier() == frame_id)
+        if (webkit_glue::GetIdentifier(cur) == frame_id)
           return GetWebFrameImpl(cur);
         cur = cur->traverseNext(true);
       } while (cur != main_frame);
@@ -489,7 +487,7 @@ void CefBrowserImpl::DidFailLoad(
 void CefBrowserImpl::DidFinishLoad(blink::WebFrame* frame) {
   blink::WebDataSource* ds = frame->dataSource();
   Send(new CefHostMsg_DidFinishLoad(routing_id(),
-                                    frame->identifier(),
+                                    webkit_glue::GetIdentifier(frame),
                                     ds->request().url(),
                                     !frame->parent(),
                                     ds->response().httpStatusCode()));
@@ -513,7 +511,7 @@ void CefBrowserImpl::DidCommitProvisionalLoad(blink::WebFrame* frame,
 }
 
 void CefBrowserImpl::FrameDetached(WebFrame* frame) {
-  int64 frame_id = frame->identifier();
+  int64 frame_id = webkit_glue::GetIdentifier(frame);
 
   if (!frames_.empty()) {
     // Remove the frame from the map.
@@ -577,9 +575,9 @@ void CefBrowserImpl::FocusedNodeChanged(const blink::WebNode& node) {
     focused_frame = render_view()->GetWebView()->focusedFrame();
   }
 
-  int64 frame_id = kInvalidFrameId;
+  int64 frame_id = webkit_glue::kInvalidFrameId;
   if (focused_frame != NULL)
-    frame_id = focused_frame->identifier();
+    frame_id = webkit_glue::GetIdentifier(focused_frame);
 
   // Don't send a message if the focused frame has not changed.
   if (frame_id == last_focused_frame_id_)

libcef/renderer/content_renderer_client.cc

@@ -9,9 +9,9 @@
 MSVC_PUSH_WARNING_LEVEL(0);
 #include "bindings/v8/V8Binding.h"
 #include "bindings/v8/V8RecursionScope.h"
-#include "bindings/v8/V8Utilities.h"
 MSVC_POP_WARNING();
 #undef ceil
+#undef FROM_HERE
 #undef LOG
 
 #include "libcef/renderer/content_renderer_client.h"
@@ -23,6 +23,7 @@ MSVC_POP_WARNING();
 #include "libcef/common/request_impl.h"
 #include "libcef/common/values_impl.h"
 #include "libcef/renderer/browser_impl.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/thread_util.h"
@@ -32,9 +33,11 @@ MSVC_POP_WARNING();
 #include "base/command_line.h"
 #include "base/path_service.h"
 #include "base/strings/string_number_conversions.h"
+#include "base/strings/utf_string_conversions.h"
 #include "chrome/renderer/loadtimes_extension_bindings.h"
 #include "chrome/renderer/printing/print_web_view_helper.h"
 #include "content/child/child_thread.h"
+#include "content/child/worker_task_runner.h"
 #include "content/common/frame_messages.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/render_process_host.h"
@@ -59,7 +62,6 @@ MSVC_POP_WARNING();
 #include "third_party/WebKit/public/web/WebView.h"
 #include "third_party/WebKit/public/web/WebWorkerInfo.h"
 #include "v8/include/v8.h"
-#include "webkit/child/worker_task_runner.h"
 
 namespace {
 
@@ -92,9 +94,9 @@ class CefPrerendererClient : public content::RenderViewObserver,
 
 // Implementation of SequencedTaskRunner for WebWorker threads.
 class CefWebWorkerTaskRunner : public base::SequencedTaskRunner,
-                               public webkit_glue::WorkerTaskRunner::Observer {
+                               public content::WorkerTaskRunner::Observer {
  public:
-  CefWebWorkerTaskRunner(webkit_glue::WorkerTaskRunner* runner,
+  CefWebWorkerTaskRunner(content::WorkerTaskRunner* runner,
                          int worker_id)
       : runner_(runner),
         worker_id_(worker_id) {
@@ -134,7 +136,7 @@ class CefWebWorkerTaskRunner : public base::SequencedTaskRunner,
   }
 
  private:
-  webkit_glue::WorkerTaskRunner* runner_;
+  content::WorkerTaskRunner* runner_;
   int worker_id_;
 };
 
@@ -309,8 +311,8 @@ scoped_refptr<base::SequencedTaskRunner>
     return render_task_runner_;
 
   // Check if a WebWorker exists for the current thread.
-  webkit_glue::WorkerTaskRunner* worker_runner =
-      webkit_glue::WorkerTaskRunner::Instance();
+  content::WorkerTaskRunner* worker_runner =
+      content::WorkerTaskRunner::Instance();
   int worker_id = worker_runner->CurrentWorkerId();
   if (worker_id > 0) {
     base::AutoLock lock_scope(worker_task_runner_lock_);
@@ -425,6 +427,7 @@ void CefContentRendererClient::RenderThreadStarted() {
 
 void CefContentRendererClient::RenderFrameCreated(
     content::RenderFrame* render_frame) {
+  new CefRenderFrameObserver(render_frame);
   BrowserCreated(render_frame->GetRenderView(), render_frame);
 }
 
@@ -444,7 +447,7 @@ bool CefContentRendererClient::OverrideCreatePlugin(
     return false;
 
 #if defined(ENABLE_PLUGINS)
-  if (UTF16ToASCII(params.mimeType) == content::kBrowserPluginMimeType)
+  if (base::UTF16ToASCII(params.mimeType) == content::kBrowserPluginMimeType)
     return false;
 
   content::RenderFrameImpl* render_frame_impl =

libcef/renderer/content_renderer_client.h

@@ -72,7 +72,6 @@ class CefContentRendererClient : public content::ContentRendererClient,
   // single-process mode. Blocks until cleanup is complete.
   void RunSingleProcessCleanup();
 
- private:
   // ContentRendererClient implementation.
   virtual void RenderThreadStarted() OVERRIDE;
   virtual void RenderFrameCreated(content::RenderFrame* render_frame) OVERRIDE;
@@ -94,13 +93,15 @@ class CefContentRendererClient : public content::ContentRendererClient,
                                       v8::Handle<v8::Context> context,
                                       int extension_group,
                                       int world_id) OVERRIDE;
-  virtual void WillReleaseScriptContext(blink::WebFrame* frame,
-                                        v8::Handle<v8::Context> context,
-                                        int world_id) OVERRIDE;
+
+  void WillReleaseScriptContext(blink::WebFrame* frame,
+                                v8::Handle<v8::Context> context,
+                                int world_id);
 
   // MessageLoop::DestructionObserver implementation.
   virtual void WillDestroyCurrentMessageLoop() OVERRIDE;
 
+ private:
   void BrowserCreated(content::RenderView* render_view,
                       content::RenderFrame* render_frame);
 

libcef/renderer/dom_document_impl.cc

@@ -88,7 +88,7 @@ CefRefPtr<CefDOMNode> CefDOMDocumentImpl::GetElementById(const CefString& id) {
 
 CefRefPtr<CefDOMNode> CefDOMDocumentImpl::GetFocusedNode() {
   const WebDocument& document = frame_->document();
-  return GetOrCreateNode(document.focusedNode());
+  return GetOrCreateNode(document.focusedElement());
 }
 
 bool CefDOMDocumentImpl::HasSelection() {

libcef/renderer/dom_event_impl.cc

@@ -75,8 +75,6 @@ CefDOMEventImpl::Category CefDOMEventImpl::GetCategory() {
     flags |= DOM_EVENT_CATEGORY_PROGRESS;
   if (event_.isXMLHttpRequestProgressEvent())
     flags |= DOM_EVENT_CATEGORY_XMLHTTPREQUEST_PROGRESS;
-  if (event_.isBeforeLoadEvent())
-    flags |= DOM_EVENT_CATEGORY_BEFORE_LOAD;
 
   return static_cast<Category>(flags);
 }

libcef/renderer/dom_node_impl.cc

@@ -47,7 +47,7 @@ class CefDOMEventListenerWrapper : public WebDOMEventListener,
       frame_(frame),
       listener_(listener) {
     // Cause this object to be deleted immediately before the frame is closed.
-    browser->AddFrameObject(frame->identifier(), this);
+    browser->AddFrameObject(webkit_glue::GetIdentifier(frame), this);
   }
   virtual ~CefDOMEventListenerWrapper() {
     CEF_REQUIRE_RT();
@@ -246,7 +246,7 @@ CefString CefDOMNodeImpl::GetValue() {
         value = select_element.value();
       }
 
-      TrimWhitespace(value, TRIM_LEADING, &value);
+      base::TrimWhitespace(value, base::TRIM_LEADING, &value);
       str = value;
     }
   }

libcef/renderer/frame_impl.cc

@@ -28,7 +28,7 @@ CefFrameImpl::CefFrameImpl(CefBrowserImpl* browser,
                            blink::WebFrame* frame)
   : browser_(browser),
     frame_(frame),
-    frame_id_(frame->identifier()) {
+    frame_id_(webkit_glue::GetIdentifier(frame)) {
 }
 
 CefFrameImpl::~CefFrameImpl() {

libcef/renderer/render_frame_observer.cc

@@ -0,0 +1,24 @@
+// Copyright 2014 The Chromium Embedded Framework 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_frame_observer.h"
+
+#include "libcef/renderer/content_renderer_client.h"
+
+#include "content/public/renderer/render_frame.h"
+
+CefRenderFrameObserver::CefRenderFrameObserver(
+    content::RenderFrame* render_frame)
+    : content::RenderFrameObserver(render_frame) {
+}
+
+CefRenderFrameObserver::~CefRenderFrameObserver() {
+}
+
+void CefRenderFrameObserver::WillReleaseScriptContext(
+    v8::Handle<v8::Context> context,
+    int world_id) {
+  CefContentRendererClient::Get()->WillReleaseScriptContext(
+      render_frame()->GetWebFrame(), context, world_id);
+}

libcef/renderer/render_frame_observer.h

@@ -0,0 +1,26 @@
+// Copyright 2014 The Chromium Embedded Framework 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 LIBCEF_RENDERER_RENDER_FRAME_OBSERVER_H_
+#define LIBCEF_RENDERER_RENDER_FRAME_OBSERVER_H_
+
+#include "content/public/renderer/render_frame_observer.h"
+
+namespace content {
+class RenderFrame;
+}
+
+class CefRenderFrameObserver : public content::RenderFrameObserver {
+ public:
+  explicit CefRenderFrameObserver(content::RenderFrame* render_frame);
+  virtual ~CefRenderFrameObserver();
+
+  virtual void WillReleaseScriptContext(v8::Handle<v8::Context> context,
+                                        int world_id) OVERRIDE;
+
+ private:
+  DISALLOW_COPY_AND_ASSIGN(CefRenderFrameObserver);
+};
+
+#endif  // LIBCEF_RENDERER_RENDER_FRAME_OBSERVER_H_

libcef/renderer/v8_impl.cc

@@ -15,12 +15,14 @@
 #include "config.h"
 MSVC_PUSH_WARNING_LEVEL(0);
 #include "core/frame/Frame.h"
+#include "core/frame/LocalFrame.h"
 #include "core/workers/WorkerGlobalScope.h"
 #include "bindings/v8/ScriptController.h"
 #include "bindings/v8/V8Binding.h"
 #include "bindings/v8/V8RecursionScope.h"
 #include "bindings/v8/WorkerScriptController.h"
 MSVC_POP_WARNING();
+#undef FROM_HERE
 #undef LOG
 
 #include "libcef/renderer/v8_impl.h"
@@ -31,6 +33,7 @@ MSVC_POP_WARNING();
 #include "libcef/common/tracker.h"
 #include "libcef/renderer/browser_impl.h"
 #include "libcef/renderer/thread_util.h"
+#include "libcef/renderer/webkit_glue.h"
 
 #include "base/bind.h"
 #include "base/lazy_instance.h"
@@ -612,21 +615,16 @@ v8::Local<v8::Value> CallV8Function(v8::Handle<v8::Context> context,
   // Execute the function call using the ScriptController so that inspector
   // instrumentation works.
   if (CEF_CURRENTLY_ON_RT()) {
-    RefPtr<WebCore::Frame> frame = WebCore::toFrameIfNotDetached(context);
+    RefPtr<WebCore::LocalFrame> frame = WebCore::toFrameIfNotDetached(context);
     DCHECK(frame);
     if (frame &&
         frame->script().canExecuteScripts(WebCore::AboutToExecuteScript)) {
       func_rv = frame->script().callFunction(function, receiver, argc, args);
     }
   } else {
-    WebCore::WorkerScriptController* controller =
-        WebCore::WorkerScriptController::controllerForContext(isolate);
-    DCHECK(controller);
-    if (controller) {
-      func_rv = WebCore::ScriptController::callFunction(
-          controller->workerGlobalScope().executionContext(),
-          function, receiver, argc, args, isolate);
-    }
+    func_rv = WebCore::ScriptController::callFunction(
+        WebCore::toExecutionContext(context),
+        function, receiver, argc, args, isolate);
   }
 
   return func_rv;
@@ -932,7 +930,7 @@ CefRefPtr<CefFrame> CefV8ContextImpl::GetFrame() {
   if (webframe) {
     CefRefPtr<CefBrowserImpl> browser =
         CefBrowserImpl::GetBrowserForMainFrame(webframe->top());
-    frame = browser->GetFrame(webframe->identifier());
+    frame = browser->GetFrame(webkit_glue::GetIdentifier(webframe));
   }
 
   return frame;

libcef/renderer/webkit_glue.cc

@@ -31,8 +31,13 @@ MSVC_PUSH_WARNING_LEVEL(0);
 MSVC_POP_WARNING();
 #undef LOG
 
+#include "base/logging.h"
+#include "content/public/renderer/render_frame.h"
+
 namespace webkit_glue {
 
+const int64 kInvalidFrameId = -1;
+
 bool CanGoBack(blink::WebView* view) {
   if (!view)
     return false;
@@ -79,4 +84,15 @@ bool SetNodeValue(blink::WebNode& node, const blink::WebString& value) {
   return true;
 }
 
+int64 GetIdentifier(blink::WebFrame* frame) {
+  // Each WebFrame will have an associated RenderFrame. The RenderFrame
+  // routing IDs are unique within a given renderer process.
+  content::RenderFrame* render_frame =
+      content::RenderFrame::FromWebFrame(frame);
+  DCHECK(render_frame);
+  if (render_frame)
+    return render_frame->GetRoutingID();
+  return kInvalidFrameId;
+}
+
 }  // webkit_glue

libcef/renderer/webkit_glue.h

@@ -7,6 +7,7 @@
 #define CEF_LIBCEF_RENDERER_WEBKIT_GLUE_H_
 
 #include <string>
+#include "base/basictypes.h"
 
 namespace v8 {
 class Context;
@@ -23,6 +24,8 @@ class WebView;
 
 namespace webkit_glue {
 
+extern const int64 kInvalidFrameId;
+
 bool CanGoBack(blink::WebView* view);
 bool CanGoForward(blink::WebView* view);
 void GoBack(blink::WebView* view);
@@ -33,6 +36,8 @@ std::string DumpDocumentText(blink::WebFrame* frame);
 
 bool SetNodeValue(blink::WebNode& node, const blink::WebString& value);
 
+int64 GetIdentifier(blink::WebFrame* frame);
+
 }  // webkit_glue
 
 #endif  // CEF_LIBCEF_RENDERER_WEBKIT_GLUE_H_