Support custom V8 bindings on WebWorker threads (issue #451).

- Add CefRenderProcessHandler callbacks for WebWorker context creation, release and uncaught exceptions.
- Add CefTaskRunner class that supports posting of tasks to standard threads and WebWorker threads.
- Organize V8 internal state information on a per-thread/per-Isolate basis.
- Add webkit_451.patch that provides the WebKit implementation.

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

libcef_dll/cpptoc/render_process_handler_cpptoc.cc

@@ -218,6 +218,90 @@ void CEF_CALLBACK render_process_handler_on_uncaught_exception(
       CefV8StackTraceCToCpp::Wrap(stackTrace));
 }
 
+void CEF_CALLBACK render_process_handler_on_worker_context_created(
+    struct _cef_render_process_handler_t* self, int worker_id,
+    const cef_string_t* url, struct _cef_v8context_t* context) {
+  // AUTO-GENERATED CONTENT - DELETE THIS COMMENT BEFORE MODIFYING
+
+  DCHECK(self);
+  if (!self)
+    return;
+  // Verify param: url; type: string_byref_const
+  DCHECK(url);
+  if (!url)
+    return;
+  // Verify param: context; type: refptr_diff
+  DCHECK(context);
+  if (!context)
+    return;
+
+  // Execute
+  CefRenderProcessHandlerCppToC::Get(self)->OnWorkerContextCreated(
+      worker_id,
+      CefString(url),
+      CefV8ContextCToCpp::Wrap(context));
+}
+
+void CEF_CALLBACK render_process_handler_on_worker_context_released(
+    struct _cef_render_process_handler_t* self, int worker_id,
+    const cef_string_t* url, struct _cef_v8context_t* context) {
+  // AUTO-GENERATED CONTENT - DELETE THIS COMMENT BEFORE MODIFYING
+
+  DCHECK(self);
+  if (!self)
+    return;
+  // Verify param: url; type: string_byref_const
+  DCHECK(url);
+  if (!url)
+    return;
+  // Verify param: context; type: refptr_diff
+  DCHECK(context);
+  if (!context)
+    return;
+
+  // Execute
+  CefRenderProcessHandlerCppToC::Get(self)->OnWorkerContextReleased(
+      worker_id,
+      CefString(url),
+      CefV8ContextCToCpp::Wrap(context));
+}
+
+void CEF_CALLBACK render_process_handler_on_worker_uncaught_exception(
+    struct _cef_render_process_handler_t* self, int worker_id,
+    const cef_string_t* url, struct _cef_v8context_t* context,
+    struct _cef_v8exception_t* exception,
+    struct _cef_v8stack_trace_t* stackTrace) {
+  // AUTO-GENERATED CONTENT - DELETE THIS COMMENT BEFORE MODIFYING
+
+  DCHECK(self);
+  if (!self)
+    return;
+  // Verify param: url; type: string_byref_const
+  DCHECK(url);
+  if (!url)
+    return;
+  // Verify param: context; type: refptr_diff
+  DCHECK(context);
+  if (!context)
+    return;
+  // Verify param: exception; type: refptr_diff
+  DCHECK(exception);
+  if (!exception)
+    return;
+  // Verify param: stackTrace; type: refptr_diff
+  DCHECK(stackTrace);
+  if (!stackTrace)
+    return;
+
+  // Execute
+  CefRenderProcessHandlerCppToC::Get(self)->OnWorkerUncaughtException(
+      worker_id,
+      CefString(url),
+      CefV8ContextCToCpp::Wrap(context),
+      CefV8ExceptionCToCpp::Wrap(exception),
+      CefV8StackTraceCToCpp::Wrap(stackTrace));
+}
+
 void CEF_CALLBACK render_process_handler_on_focused_node_changed(
     struct _cef_render_process_handler_t* self, cef_browser_t* browser,
     cef_frame_t* frame, cef_domnode_t* node) {
@@ -290,6 +374,12 @@ CefRenderProcessHandlerCppToC::CefRenderProcessHandlerCppToC(
       render_process_handler_on_context_released;
   struct_.struct_.on_uncaught_exception =
       render_process_handler_on_uncaught_exception;
+  struct_.struct_.on_worker_context_created =
+      render_process_handler_on_worker_context_created;
+  struct_.struct_.on_worker_context_released =
+      render_process_handler_on_worker_context_released;
+  struct_.struct_.on_worker_uncaught_exception =
+      render_process_handler_on_worker_uncaught_exception;
   struct_.struct_.on_focused_node_changed =
       render_process_handler_on_focused_node_changed;
   struct_.struct_.on_process_message_received =

libcef_dll/cpptoc/task_cpptoc.cc

@@ -15,8 +15,7 @@
 
 // MEMBER FUNCTIONS - Body may be edited by hand.
 
-void CEF_CALLBACK task_execute(struct _cef_task_t* self,
-    cef_thread_id_t threadId) {
+void CEF_CALLBACK task_execute(struct _cef_task_t* self) {
   // AUTO-GENERATED CONTENT - DELETE THIS COMMENT BEFORE MODIFYING
 
   DCHECK(self);
@@ -24,8 +23,7 @@ void CEF_CALLBACK task_execute(struct _cef_task_t* self,
     return;
 
   // Execute
-  CefTaskCppToC::Get(self)->Execute(
-      threadId);
+  CefTaskCppToC::Get(self)->Execute();
 }
 
 

libcef_dll/cpptoc/task_runner_cpptoc.cc

@@ -0,0 +1,153 @@
+// Copyright (c) 2013 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.
+//
+// ---------------------------------------------------------------------------
+//
+// This file was generated by the CEF translator tool. If making changes by
+// hand only do so within the body of existing method and function
+// implementations. See the translator.README.txt file in the tools directory
+// for more information.
+//
+
+#include "libcef_dll/cpptoc/task_runner_cpptoc.h"
+#include "libcef_dll/ctocpp/task_ctocpp.h"
+
+
+// GLOBAL FUNCTIONS - Body may be edited by hand.
+
+CEF_EXPORT cef_task_runner_t* cef_task_runner_get_for_current_thread() {
+  // AUTO-GENERATED CONTENT - DELETE THIS COMMENT BEFORE MODIFYING
+
+  // Execute
+  CefRefPtr<CefTaskRunner> _retval = CefTaskRunner::GetForCurrentThread();
+
+  // Return type: refptr_same
+  return CefTaskRunnerCppToC::Wrap(_retval);
+}
+
+CEF_EXPORT cef_task_runner_t* cef_task_runner_get_for_thread(
+    cef_thread_id_t threadId) {
+  // AUTO-GENERATED CONTENT - DELETE THIS COMMENT BEFORE MODIFYING
+
+  // Execute
+  CefRefPtr<CefTaskRunner> _retval = CefTaskRunner::GetForThread(
+      threadId);
+
+  // Return type: refptr_same
+  return CefTaskRunnerCppToC::Wrap(_retval);
+}
+
+
+// MEMBER FUNCTIONS - Body may be edited by hand.
+
+int CEF_CALLBACK task_runner_is_same(struct _cef_task_runner_t* self,
+    struct _cef_task_runner_t* that) {
+  // AUTO-GENERATED CONTENT - DELETE THIS COMMENT BEFORE MODIFYING
+
+  DCHECK(self);
+  if (!self)
+    return 0;
+  // Verify param: that; type: refptr_same
+  DCHECK(that);
+  if (!that)
+    return 0;
+
+  // Execute
+  bool _retval = CefTaskRunnerCppToC::Get(self)->IsSame(
+      CefTaskRunnerCppToC::Unwrap(that));
+
+  // Return type: bool
+  return _retval;
+}
+
+int CEF_CALLBACK task_runner_belongs_to_current_thread(
+    struct _cef_task_runner_t* self) {
+  // AUTO-GENERATED CONTENT - DELETE THIS COMMENT BEFORE MODIFYING
+
+  DCHECK(self);
+  if (!self)
+    return 0;
+
+  // Execute
+  bool _retval = CefTaskRunnerCppToC::Get(self)->BelongsToCurrentThread();
+
+  // Return type: bool
+  return _retval;
+}
+
+int CEF_CALLBACK task_runner_belongs_to_thread(struct _cef_task_runner_t* self,
+    cef_thread_id_t threadId) {
+  // AUTO-GENERATED CONTENT - DELETE THIS COMMENT BEFORE MODIFYING
+
+  DCHECK(self);
+  if (!self)
+    return 0;
+
+  // Execute
+  bool _retval = CefTaskRunnerCppToC::Get(self)->BelongsToThread(
+      threadId);
+
+  // Return type: bool
+  return _retval;
+}
+
+int CEF_CALLBACK task_runner_post_task(struct _cef_task_runner_t* self,
+    cef_task_t* task) {
+  // AUTO-GENERATED CONTENT - DELETE THIS COMMENT BEFORE MODIFYING
+
+  DCHECK(self);
+  if (!self)
+    return 0;
+  // Verify param: task; type: refptr_diff
+  DCHECK(task);
+  if (!task)
+    return 0;
+
+  // Execute
+  bool _retval = CefTaskRunnerCppToC::Get(self)->PostTask(
+      CefTaskCToCpp::Wrap(task));
+
+  // Return type: bool
+  return _retval;
+}
+
+int CEF_CALLBACK task_runner_post_delayed_task(struct _cef_task_runner_t* self,
+    cef_task_t* task, int64 delay_ms) {
+  // AUTO-GENERATED CONTENT - DELETE THIS COMMENT BEFORE MODIFYING
+
+  DCHECK(self);
+  if (!self)
+    return 0;
+  // Verify param: task; type: refptr_diff
+  DCHECK(task);
+  if (!task)
+    return 0;
+
+  // Execute
+  bool _retval = CefTaskRunnerCppToC::Get(self)->PostDelayedTask(
+      CefTaskCToCpp::Wrap(task),
+      delay_ms);
+
+  // Return type: bool
+  return _retval;
+}
+
+
+// CONSTRUCTOR - Do not edit by hand.
+
+CefTaskRunnerCppToC::CefTaskRunnerCppToC(CefTaskRunner* cls)
+    : CefCppToC<CefTaskRunnerCppToC, CefTaskRunner, cef_task_runner_t>(cls) {
+  struct_.struct_.is_same = task_runner_is_same;
+  struct_.struct_.belongs_to_current_thread =
+      task_runner_belongs_to_current_thread;
+  struct_.struct_.belongs_to_thread = task_runner_belongs_to_thread;
+  struct_.struct_.post_task = task_runner_post_task;
+  struct_.struct_.post_delayed_task = task_runner_post_delayed_task;
+}
+
+#ifndef NDEBUG
+template<> long CefCppToC<CefTaskRunnerCppToC, CefTaskRunner,
+    cef_task_runner_t>::DebugObjCt = 0;
+#endif
+

libcef_dll/cpptoc/task_runner_cpptoc.h

@@ -0,0 +1,36 @@
+// Copyright (c) 2013 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.
+//
+// ---------------------------------------------------------------------------
+//
+// This file was generated by the CEF translator tool. If making changes by
+// hand only do so within the body of existing method and function
+// implementations. See the translator.README.txt file in the tools directory
+// for more information.
+//
+
+#ifndef CEF_LIBCEF_DLL_CPPTOC_TASK_RUNNER_CPPTOC_H_
+#define CEF_LIBCEF_DLL_CPPTOC_TASK_RUNNER_CPPTOC_H_
+#pragma once
+
+#ifndef BUILDING_CEF_SHARED
+#pragma message("Warning: "__FILE__" may be accessed DLL-side only")
+#else  // BUILDING_CEF_SHARED
+
+#include "include/cef_task.h"
+#include "include/capi/cef_task_capi.h"
+#include "libcef_dll/cpptoc/cpptoc.h"
+
+// Wrap a C++ class with a C structure.
+// This class may be instantiated and accessed DLL-side only.
+class CefTaskRunnerCppToC
+    : public CefCppToC<CefTaskRunnerCppToC, CefTaskRunner, cef_task_runner_t> {
+ public:
+  explicit CefTaskRunnerCppToC(CefTaskRunner* cls);
+  virtual ~CefTaskRunnerCppToC() {}
+};
+
+#endif  // BUILDING_CEF_SHARED
+#endif  // CEF_LIBCEF_DLL_CPPTOC_TASK_RUNNER_CPPTOC_H_
+

libcef_dll/cpptoc/v8context_cpptoc.cc

@@ -12,6 +12,7 @@
 
 #include "libcef_dll/cpptoc/browser_cpptoc.h"
 #include "libcef_dll/cpptoc/frame_cpptoc.h"
+#include "libcef_dll/cpptoc/task_runner_cpptoc.h"
 #include "libcef_dll/cpptoc/v8context_cpptoc.h"
 #include "libcef_dll/cpptoc/v8exception_cpptoc.h"
 #include "libcef_dll/cpptoc/v8value_cpptoc.h"
@@ -52,6 +53,22 @@ CEF_EXPORT int cef_v8context_in_context() {
 
 // MEMBER FUNCTIONS - Body may be edited by hand.
 
+cef_task_runner_t* CEF_CALLBACK v8context_get_task_runner(
+    struct _cef_v8context_t* self) {
+  // AUTO-GENERATED CONTENT - DELETE THIS COMMENT BEFORE MODIFYING
+
+  DCHECK(self);
+  if (!self)
+    return NULL;
+
+  // Execute
+  CefRefPtr<CefTaskRunner> _retval = CefV8ContextCppToC::Get(
+      self)->GetTaskRunner();
+
+  // Return type: refptr_same
+  return CefTaskRunnerCppToC::Wrap(_retval);
+}
+
 int CEF_CALLBACK v8context_is_valid(struct _cef_v8context_t* self) {
   // AUTO-GENERATED CONTENT - DELETE THIS COMMENT BEFORE MODIFYING
 
@@ -226,6 +243,7 @@ int CEF_CALLBACK v8context_eval(struct _cef_v8context_t* self,
 
 CefV8ContextCppToC::CefV8ContextCppToC(CefV8Context* cls)
     : CefCppToC<CefV8ContextCppToC, CefV8Context, cef_v8context_t>(cls) {
+  struct_.struct_.get_task_runner = v8context_get_task_runner;
   struct_.struct_.is_valid = v8context_is_valid;
   struct_.struct_.get_browser = v8context_get_browser;
   struct_.struct_.get_frame = v8context_get_frame;

libcef_dll/ctocpp/render_process_handler_ctocpp.cc

@@ -214,6 +214,87 @@ void CefRenderProcessHandlerCToCpp::OnUncaughtException(
       CefV8StackTraceCppToC::Wrap(stackTrace));
 }
 
+void CefRenderProcessHandlerCToCpp::OnWorkerContextCreated(int worker_id,
+    const CefString& url, CefRefPtr<CefV8Context> context) {
+  if (CEF_MEMBER_MISSING(struct_, on_worker_context_created))
+    return;
+
+  // AUTO-GENERATED CONTENT - DELETE THIS COMMENT BEFORE MODIFYING
+
+  // Verify param: url; type: string_byref_const
+  DCHECK(!url.empty());
+  if (url.empty())
+    return;
+  // Verify param: context; type: refptr_diff
+  DCHECK(context.get());
+  if (!context.get())
+    return;
+
+  // Execute
+  struct_->on_worker_context_created(struct_,
+      worker_id,
+      url.GetStruct(),
+      CefV8ContextCppToC::Wrap(context));
+}
+
+void CefRenderProcessHandlerCToCpp::OnWorkerContextReleased(int worker_id,
+    const CefString& url, CefRefPtr<CefV8Context> context) {
+  if (CEF_MEMBER_MISSING(struct_, on_worker_context_released))
+    return;
+
+  // AUTO-GENERATED CONTENT - DELETE THIS COMMENT BEFORE MODIFYING
+
+  // Verify param: url; type: string_byref_const
+  DCHECK(!url.empty());
+  if (url.empty())
+    return;
+  // Verify param: context; type: refptr_diff
+  DCHECK(context.get());
+  if (!context.get())
+    return;
+
+  // Execute
+  struct_->on_worker_context_released(struct_,
+      worker_id,
+      url.GetStruct(),
+      CefV8ContextCppToC::Wrap(context));
+}
+
+void CefRenderProcessHandlerCToCpp::OnWorkerUncaughtException(int worker_id,
+    const CefString& url, CefRefPtr<CefV8Context> context,
+    CefRefPtr<CefV8Exception> exception,
+    CefRefPtr<CefV8StackTrace> stackTrace) {
+  if (CEF_MEMBER_MISSING(struct_, on_worker_uncaught_exception))
+    return;
+
+  // AUTO-GENERATED CONTENT - DELETE THIS COMMENT BEFORE MODIFYING
+
+  // Verify param: url; type: string_byref_const
+  DCHECK(!url.empty());
+  if (url.empty())
+    return;
+  // Verify param: context; type: refptr_diff
+  DCHECK(context.get());
+  if (!context.get())
+    return;
+  // Verify param: exception; type: refptr_diff
+  DCHECK(exception.get());
+  if (!exception.get())
+    return;
+  // Verify param: stackTrace; type: refptr_diff
+  DCHECK(stackTrace.get());
+  if (!stackTrace.get())
+    return;
+
+  // Execute
+  struct_->on_worker_uncaught_exception(struct_,
+      worker_id,
+      url.GetStruct(),
+      CefV8ContextCppToC::Wrap(context),
+      CefV8ExceptionCppToC::Wrap(exception),
+      CefV8StackTraceCppToC::Wrap(stackTrace));
+}
+
 void CefRenderProcessHandlerCToCpp::OnFocusedNodeChanged(
     CefRefPtr<CefBrowser> browser, CefRefPtr<CefFrame> frame,
     CefRefPtr<CefDOMNode> node) {

libcef_dll/ctocpp/render_process_handler_ctocpp.h

@@ -50,6 +50,13 @@ class CefRenderProcessHandlerCToCpp
       CefRefPtr<CefFrame> frame, CefRefPtr<CefV8Context> context,
       CefRefPtr<CefV8Exception> exception,
       CefRefPtr<CefV8StackTrace> stackTrace) OVERRIDE;
+  virtual void OnWorkerContextCreated(int worker_id, const CefString& url,
+      CefRefPtr<CefV8Context> context) OVERRIDE;
+  virtual void OnWorkerContextReleased(int worker_id, const CefString& url,
+      CefRefPtr<CefV8Context> context) OVERRIDE;
+  virtual void OnWorkerUncaughtException(int worker_id, const CefString& url,
+      CefRefPtr<CefV8Context> context, CefRefPtr<CefV8Exception> exception,
+      CefRefPtr<CefV8StackTrace> stackTrace) OVERRIDE;
   virtual void OnFocusedNodeChanged(CefRefPtr<CefBrowser> browser,
       CefRefPtr<CefFrame> frame, CefRefPtr<CefDOMNode> node) OVERRIDE;
   virtual bool OnProcessMessageReceived(CefRefPtr<CefBrowser> browser,

libcef_dll/ctocpp/task_ctocpp.cc

@@ -15,15 +15,14 @@
 
 // VIRTUAL METHODS - Body may be edited by hand.
 
-void CefTaskCToCpp::Execute(CefThreadId threadId) {
+void CefTaskCToCpp::Execute() {
   if (CEF_MEMBER_MISSING(struct_, execute))
     return;
 
   // AUTO-GENERATED CONTENT - DELETE THIS COMMENT BEFORE MODIFYING
 
   // Execute
-  struct_->execute(struct_,
-      threadId);
+  struct_->execute(struct_);
 }
 
 

libcef_dll/ctocpp/task_ctocpp.h

@@ -32,7 +32,7 @@ class CefTaskCToCpp
   virtual ~CefTaskCToCpp() {}
 
   // CefTask methods
-  virtual void Execute(CefThreadId threadId) OVERRIDE;
+  virtual void Execute() OVERRIDE;
 };
 
 #endif  // BUILDING_CEF_SHARED

libcef_dll/ctocpp/task_runner_ctocpp.cc

@@ -0,0 +1,134 @@
+// Copyright (c) 2013 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.
+//
+// ---------------------------------------------------------------------------
+//
+// This file was generated by the CEF translator tool. If making changes by
+// hand only do so within the body of existing method and function
+// implementations. See the translator.README.txt file in the tools directory
+// for more information.
+//
+
+#include "libcef_dll/cpptoc/task_cpptoc.h"
+#include "libcef_dll/ctocpp/task_runner_ctocpp.h"
+
+
+// STATIC METHODS - Body may be edited by hand.
+
+CefRefPtr<CefTaskRunner> CefTaskRunner::GetForCurrentThread() {
+  // AUTO-GENERATED CONTENT - DELETE THIS COMMENT BEFORE MODIFYING
+
+  // Execute
+  cef_task_runner_t* _retval = cef_task_runner_get_for_current_thread();
+
+  // Return type: refptr_same
+  return CefTaskRunnerCToCpp::Wrap(_retval);
+}
+
+CefRefPtr<CefTaskRunner> CefTaskRunner::GetForThread(CefThreadId threadId) {
+  // AUTO-GENERATED CONTENT - DELETE THIS COMMENT BEFORE MODIFYING
+
+  // Execute
+  cef_task_runner_t* _retval = cef_task_runner_get_for_thread(
+      threadId);
+
+  // Return type: refptr_same
+  return CefTaskRunnerCToCpp::Wrap(_retval);
+}
+
+
+// VIRTUAL METHODS - Body may be edited by hand.
+
+bool CefTaskRunnerCToCpp::IsSame(CefRefPtr<CefTaskRunner> that) {
+  if (CEF_MEMBER_MISSING(struct_, is_same))
+    return false;
+
+  // AUTO-GENERATED CONTENT - DELETE THIS COMMENT BEFORE MODIFYING
+
+  // Verify param: that; type: refptr_same
+  DCHECK(that.get());
+  if (!that.get())
+    return false;
+
+  // Execute
+  int _retval = struct_->is_same(struct_,
+      CefTaskRunnerCToCpp::Unwrap(that));
+
+  // Return type: bool
+  return _retval?true:false;
+}
+
+bool CefTaskRunnerCToCpp::BelongsToCurrentThread() {
+  if (CEF_MEMBER_MISSING(struct_, belongs_to_current_thread))
+    return false;
+
+  // AUTO-GENERATED CONTENT - DELETE THIS COMMENT BEFORE MODIFYING
+
+  // Execute
+  int _retval = struct_->belongs_to_current_thread(struct_);
+
+  // Return type: bool
+  return _retval?true:false;
+}
+
+bool CefTaskRunnerCToCpp::BelongsToThread(CefThreadId threadId) {
+  if (CEF_MEMBER_MISSING(struct_, belongs_to_thread))
+    return false;
+
+  // AUTO-GENERATED CONTENT - DELETE THIS COMMENT BEFORE MODIFYING
+
+  // Execute
+  int _retval = struct_->belongs_to_thread(struct_,
+      threadId);
+
+  // Return type: bool
+  return _retval?true:false;
+}
+
+bool CefTaskRunnerCToCpp::PostTask(CefRefPtr<CefTask> task) {
+  if (CEF_MEMBER_MISSING(struct_, post_task))
+    return false;
+
+  // AUTO-GENERATED CONTENT - DELETE THIS COMMENT BEFORE MODIFYING
+
+  // Verify param: task; type: refptr_diff
+  DCHECK(task.get());
+  if (!task.get())
+    return false;
+
+  // Execute
+  int _retval = struct_->post_task(struct_,
+      CefTaskCppToC::Wrap(task));
+
+  // Return type: bool
+  return _retval?true:false;
+}
+
+bool CefTaskRunnerCToCpp::PostDelayedTask(CefRefPtr<CefTask> task,
+    int64 delay_ms) {
+  if (CEF_MEMBER_MISSING(struct_, post_delayed_task))
+    return false;
+
+  // AUTO-GENERATED CONTENT - DELETE THIS COMMENT BEFORE MODIFYING
+
+  // Verify param: task; type: refptr_diff
+  DCHECK(task.get());
+  if (!task.get())
+    return false;
+
+  // Execute
+  int _retval = struct_->post_delayed_task(struct_,
+      CefTaskCppToC::Wrap(task),
+      delay_ms);
+
+  // Return type: bool
+  return _retval?true:false;
+}
+
+
+#ifndef NDEBUG
+template<> long CefCToCpp<CefTaskRunnerCToCpp, CefTaskRunner,
+    cef_task_runner_t>::DebugObjCt = 0;
+#endif
+

libcef_dll/ctocpp/task_runner_ctocpp.h

@@ -0,0 +1,45 @@
+// Copyright (c) 2013 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.
+//
+// ---------------------------------------------------------------------------
+//
+// This file was generated by the CEF translator tool. If making changes by
+// hand only do so within the body of existing method and function
+// implementations. See the translator.README.txt file in the tools directory
+// for more information.
+//
+
+#ifndef CEF_LIBCEF_DLL_CTOCPP_TASK_RUNNER_CTOCPP_H_
+#define CEF_LIBCEF_DLL_CTOCPP_TASK_RUNNER_CTOCPP_H_
+#pragma once
+
+#ifndef USING_CEF_SHARED
+#pragma message("Warning: "__FILE__" may be accessed wrapper-side only")
+#else  // USING_CEF_SHARED
+
+#include "include/cef_task.h"
+#include "include/capi/cef_task_capi.h"
+#include "libcef_dll/ctocpp/ctocpp.h"
+
+// Wrap a C structure with a C++ class.
+// This class may be instantiated and accessed wrapper-side only.
+class CefTaskRunnerCToCpp
+    : public CefCToCpp<CefTaskRunnerCToCpp, CefTaskRunner, cef_task_runner_t> {
+ public:
+  explicit CefTaskRunnerCToCpp(cef_task_runner_t* str)
+      : CefCToCpp<CefTaskRunnerCToCpp, CefTaskRunner, cef_task_runner_t>(str) {}
+  virtual ~CefTaskRunnerCToCpp() {}
+
+  // CefTaskRunner methods
+  virtual bool IsSame(CefRefPtr<CefTaskRunner> that) OVERRIDE;
+  virtual bool BelongsToCurrentThread() OVERRIDE;
+  virtual bool BelongsToThread(CefThreadId threadId) OVERRIDE;
+  virtual bool PostTask(CefRefPtr<CefTask> task) OVERRIDE;
+  virtual bool PostDelayedTask(CefRefPtr<CefTask> task,
+      int64 delay_ms) OVERRIDE;
+};
+
+#endif  // USING_CEF_SHARED
+#endif  // CEF_LIBCEF_DLL_CTOCPP_TASK_RUNNER_CTOCPP_H_
+

libcef_dll/ctocpp/v8context_ctocpp.cc

@@ -12,6 +12,7 @@
 
 #include "libcef_dll/ctocpp/browser_ctocpp.h"
 #include "libcef_dll/ctocpp/frame_ctocpp.h"
+#include "libcef_dll/ctocpp/task_runner_ctocpp.h"
 #include "libcef_dll/ctocpp/v8context_ctocpp.h"
 #include "libcef_dll/ctocpp/v8exception_ctocpp.h"
 #include "libcef_dll/ctocpp/v8value_ctocpp.h"
@@ -52,6 +53,19 @@ bool CefV8Context::InContext() {
 
 // VIRTUAL METHODS - Body may be edited by hand.
 
+CefRefPtr<CefTaskRunner> CefV8ContextCToCpp::GetTaskRunner() {
+  if (CEF_MEMBER_MISSING(struct_, get_task_runner))
+    return NULL;
+
+  // AUTO-GENERATED CONTENT - DELETE THIS COMMENT BEFORE MODIFYING
+
+  // Execute
+  cef_task_runner_t* _retval = struct_->get_task_runner(struct_);
+
+  // Return type: refptr_same
+  return CefTaskRunnerCToCpp::Wrap(_retval);
+}
+
 bool CefV8ContextCToCpp::IsValid() {
   if (CEF_MEMBER_MISSING(struct_, is_valid))
     return false;

libcef_dll/ctocpp/v8context_ctocpp.h

@@ -32,6 +32,7 @@ class CefV8ContextCToCpp
   virtual ~CefV8ContextCToCpp() {}
 
   // CefV8Context methods
+  virtual CefRefPtr<CefTaskRunner> GetTaskRunner() OVERRIDE;
   virtual bool IsValid() OVERRIDE;
   virtual CefRefPtr<CefBrowser> GetBrowser() OVERRIDE;
   virtual CefRefPtr<CefFrame> GetFrame() OVERRIDE;

libcef_dll/libcef_dll.cc

@@ -58,6 +58,7 @@
 #include "libcef_dll/cpptoc/scheme_registrar_cpptoc.h"
 #include "libcef_dll/cpptoc/stream_reader_cpptoc.h"
 #include "libcef_dll/cpptoc/stream_writer_cpptoc.h"
+#include "libcef_dll/cpptoc/task_runner_cpptoc.h"
 #include "libcef_dll/cpptoc/urlrequest_cpptoc.h"
 #include "libcef_dll/cpptoc/v8context_cpptoc.h"
 #include "libcef_dll/cpptoc/v8exception_cpptoc.h"
@@ -221,6 +222,7 @@ CEF_EXPORT void cef_shutdown() {
   DCHECK_EQ(CefStreamWriterCppToC::DebugObjCt, 0);
   DCHECK_EQ(CefStringVisitorCToCpp::DebugObjCt, 0);
   DCHECK_EQ(CefTaskCToCpp::DebugObjCt, 0);
+  DCHECK_EQ(CefTaskRunnerCppToC::DebugObjCt, 0);
   DCHECK_EQ(CefTraceClientCToCpp::DebugObjCt, 0);
   DCHECK_EQ(CefURLRequestClientCToCpp::DebugObjCt, 0);
   DCHECK_EQ(CefURLRequestCppToC::DebugObjCt, 0);

libcef_dll/wrapper/libcef_dll_wrapper.cc

@@ -93,6 +93,7 @@
 #include "libcef_dll/ctocpp/scheme_registrar_ctocpp.h"
 #include "libcef_dll/ctocpp/stream_reader_ctocpp.h"
 #include "libcef_dll/ctocpp/stream_writer_ctocpp.h"
+#include "libcef_dll/ctocpp/task_runner_ctocpp.h"
 #include "libcef_dll/ctocpp/urlrequest_ctocpp.h"
 #include "libcef_dll/ctocpp/v8context_ctocpp.h"
 #include "libcef_dll/ctocpp/v8exception_ctocpp.h"
@@ -213,6 +214,7 @@ CEF_GLOBAL void CefShutdown() {
   DCHECK_EQ(CefStreamWriterCToCpp::DebugObjCt, 0);
   DCHECK_EQ(CefStringVisitorCppToC::DebugObjCt, 0);
   DCHECK_EQ(CefTaskCppToC::DebugObjCt, 0);
+  DCHECK_EQ(CefTaskRunnerCToCpp::DebugObjCt, 0);
   DCHECK_EQ(CefTraceClientCppToC::DebugObjCt, 0);
   DCHECK_EQ(CefURLRequestCToCpp::DebugObjCt, 0);
   DCHECK_EQ(CefURLRequestClientCppToC::DebugObjCt, 0);