git.sesse.net Git - casparcg/blob - dependencies64/cef/include/capi/cef_task_capi.h

   1 // Copyright (c) 2015 Marshall A. Greenblatt. All rights reserved.
   2 //
   3 // Redistribution and use in source and binary forms, with or without
   4 // modification, are permitted provided that the following conditions are
   5 // met:
   6 //
   7 //    * Redistributions of source code must retain the above copyright
   8 // notice, this list of conditions and the following disclaimer.
   9 //    * Redistributions in binary form must reproduce the above
  10 // copyright notice, this list of conditions and the following disclaimer
  11 // in the documentation and/or other materials provided with the
  12 // distribution.
  13 //    * Neither the name of Google Inc. nor the name Chromium Embedded
  14 // Framework nor the names of its contributors may be used to endorse
  15 // or promote products derived from this software without specific prior
  16 // written permission.
  17 //
  18 // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
  19 // "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
  20 // LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
  21 // A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
  22 // OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  23 // SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
  24 // LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  25 // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  26 // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  27 // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  28 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  29 //
  30 // ---------------------------------------------------------------------------
  31 //
  32 // This file was generated by the CEF translator tool and should not edited
  33 // by hand. See the translator.README.txt file in the tools directory for
  34 // more information.
  35 //
  36
  37 #ifndef CEF_INCLUDE_CAPI_CEF_TASK_CAPI_H_
  38 #define CEF_INCLUDE_CAPI_CEF_TASK_CAPI_H_
  39 #pragma once
  40
  41 #include "include/capi/cef_base_capi.h"
  42
  43 #ifdef __cplusplus
  44 extern "C" {
  45 #endif
  46
  47
  48 ///
  49 // Implement this structure for asynchronous task execution. If the task is
  50 // posted successfully and if the associated message loop is still running then
  51 // the execute() function will be called on the target thread. If the task fails
  52 // to post then the task object may be destroyed on the source thread instead of
  53 // the target thread. For this reason be cautious when performing work in the
  54 // task object destructor.
  55 ///
  56 typedef struct _cef_task_t {
  57   ///
  58   // Base structure.
  59   ///
  60   cef_base_t base;
  61
  62   ///
  63   // Method that will be executed on the target thread.
  64   ///
  65   void (CEF_CALLBACK *execute)(struct _cef_task_t* self);
  66 } cef_task_t;
  67
  68
  69 ///
  70 // Structure that asynchronously executes tasks on the associated thread. It is
  71 // safe to call the functions of this structure on any thread.
  72 //
  73 // CEF maintains multiple internal threads that are used for handling different
  74 // types of tasks in different processes. The cef_thread_id_t definitions in
  75 // cef_types.h list the common CEF threads. Task runners are also available for
  76 // other CEF threads as appropriate (for example, V8 WebWorker threads).
  77 ///
  78 typedef struct _cef_task_runner_t {
  79   ///
  80   // Base structure.
  81   ///
  82   cef_base_t base;
  83
  84   ///
  85   // Returns true (1) if this object is pointing to the same task runner as
  86   // |that| object.
  87   ///
  88   int (CEF_CALLBACK *is_same)(struct _cef_task_runner_t* self,
  89       struct _cef_task_runner_t* that);
  90
  91   ///
  92   // Returns true (1) if this task runner belongs to the current thread.
  93   ///
  94   int (CEF_CALLBACK *belongs_to_current_thread)(
  95       struct _cef_task_runner_t* self);
  96
  97   ///
  98   // Returns true (1) if this task runner is for the specified CEF thread.
  99   ///
 100   int (CEF_CALLBACK *belongs_to_thread)(struct _cef_task_runner_t* self,
 101       cef_thread_id_t threadId);
 102
 103   ///
 104   // Post a task for execution on the thread associated with this task runner.
 105   // Execution will occur asynchronously.
 106   ///
 107   int (CEF_CALLBACK *post_task)(struct _cef_task_runner_t* self,
 108       struct _cef_task_t* task);
 109
 110   ///
 111   // Post a task for delayed execution on the thread associated with this task
 112   // runner. Execution will occur asynchronously. Delayed tasks are not
 113   // supported on V8 WebWorker threads and will be executed without the
 114   // specified delay.
 115   ///
 116   int (CEF_CALLBACK *post_delayed_task)(struct _cef_task_runner_t* self,
 117       struct _cef_task_t* task, int64 delay_ms);
 118 } cef_task_runner_t;
 119
 120
 121 ///
 122 // Returns the task runner for the current thread. Only CEF threads will have
 123 // task runners. An NULL reference will be returned if this function is called
 124 // on an invalid thread.
 125 ///
 126 CEF_EXPORT cef_task_runner_t* cef_task_runner_get_for_current_thread();
 127
 128 ///
 129 // Returns the task runner for the specified CEF thread.
 130 ///
 131 CEF_EXPORT cef_task_runner_t* cef_task_runner_get_for_thread(
 132     cef_thread_id_t threadId);
 133
 134
 135 ///
 136 // Returns true (1) if called on the specified thread. Equivalent to using
 137 // cef_task_tRunner::GetForThread(threadId)->belongs_to_current_thread().
 138 ///
 139 CEF_EXPORT int cef_currently_on(cef_thread_id_t threadId);
 140
 141 ///
 142 // Post a task for execution on the specified thread. Equivalent to using
 143 // cef_task_tRunner::GetForThread(threadId)->PostTask(task).
 144 ///
 145 CEF_EXPORT int cef_post_task(cef_thread_id_t threadId, cef_task_t* task);
 146
 147 ///
 148 // Post a task for delayed execution on the specified thread. Equivalent to
 149 // using cef_task_tRunner::GetForThread(threadId)->PostDelayedTask(task,
 150 // delay_ms).
 151 ///
 152 CEF_EXPORT int cef_post_delayed_task(cef_thread_id_t threadId, cef_task_t* task,
 153     int64 delay_ms);
 154
 155 #ifdef __cplusplus
 156 }
 157 #endif
 158
 159 #endif  // CEF_INCLUDE_CAPI_CEF_TASK_CAPI_H_