| /external/chromium/base/ |
| message_loop.cc | 122 // Clean up any unprocessed tasks, but take care: deleting a task could
124 // limit on the number of times we will allow a deleted task to generate more
126 // we end up hitting the loop limit, then it is probably due to one task that
218 Task* task = deferred_non_nestable_work_queue_.front().task;
221 RunTask(task);
237 const tracked_objects::Location& from_here, Task* task) {
238 PostTask_Helper(from_here, task, 0, true)
394 Task* task = NULL; local
407 Task* task = delayed_work_queue_.top().task; local
[all...] |
| worker_pool_linux_unittest.cc | 12 #include "base/task.h"
28 const std::queue<Task*>& tasks() const { return pool_->tasks_; }
53 class IncrementingTask : public Task {
86 class BlockingIncrementingTask : public Task {
156 Task* CreateNewIncrementingTask() {
161 Task* CreateNewBlockingIncrementingTask() {
185 // Add one task and wait for it to be completed.
191 "There should be only one thread allocated for one task.";
197 // Add one task and wait for it to be completed.
259 // Add another non blocking task. There are no threads to reuse
[all...] |
| waitable_event_watcher_posix.cc | 18 // That AsyncWaiter has a pointer to MessageLoop, and a Task to be posted to it.
19 // The MessageLoop ends up running the task, which calls the delegate.
24 // the MessageLoop which runs the Task, we are assured that the delegate cannot
50 // This is an asynchronous waiter which posts a task to a MessageLoop when
55 AsyncWaiter(MessageLoop* message_loop, Task* task, Flag* flag)
57 cb_task_(task),
62 // If the callback has been canceled, we don't enqueue the task, we just
85 Task *const cb_task_;
91 // this by posting this task, which calls the delegate and keeps track of whe
[all...] |
| message_pump_glib_unittest.cc | 60 if (event.task) {
61 event.task->Run();
62 delete event.task;
66 // Adds an event to the queue. When "handled", executes |task|.
68 void AddEvent(int delay_ms, Task* task) {
76 EventInjector::Event event = { future, task };
90 Task* task; member in struct:__anon2359::EventInjector::Event
127 // Does nothing. This function can be called from a task
[all...] |
| thread_unittest.cc | 19 class ToggleValue : public Task {
32 class SleepSome : public Task {
94 // wait for the task to run (we could use a kernel event here
|
| task.h | 14 // Task ------------------------------------------------------------------------
16 // A task is a generic runnable thingy, usually used for running code on a
19 class Task : public tracked_objects::Tracked {
21 Task() {}
22 virtual ~Task() {}
28 class CancelableTask : public Task {
62 // // If you'd like to only only have one pending task at a time, test for
63 // // |empty| before manufacturing another task.
85 inline Task* NewRunnableMethod(Method method) {
91 inline Task* NewRunnableMethod(Method method, const A& a)
[all...] |
| message_loop_unittest.cc | 155 class SlowTask : public Task {
191 // Test that PostDelayedTask results in a delayed task.
261 // Test that a delayed task still runs after a normal tasks even if the
287 // Test that a delayed task still runs after a pile of normal tasks. The key
290 // to maybe run the delayed task. It should know not to do so until the
291 // delayed task's delay has passed.
312 // Test that the interval of the timer, used to run the next delayed task, is
313 // set to a value corresponding to when the next delayed task should run.
315 // By setting num_tasks to 1, we ensure that the first task to run causes the
346 class SubPumpTask : public Task {
1040 Task* task = new OrderedTasks(&order, 1); local
1065 Task* task = new OrderedTasks(&order, 2); local
1131 Task* task = new MyTask(); local
1157 Task* task = new MyTask(); local
1250 IOHandlerTask* task = new IOHandlerTask(&handler); local
[all...] |
| directory_watcher_inotify.cc | 28 #include "base/task.h"
138 // Event signaled when the background task finished adding initial inotify
145 class RegisterSubtreeWatchesTask : public Task {
173 class DirectoryWatcherImplNotifyTask : public Task {
192 class InotifyReaderTask : public Task {
457 Task* subtree_task = new RegisterSubtreeWatchesTask(this, root_path_);
|
| object_watcher.cc | 13 struct ObjectWatcher::Watch : public Task {
99 // task, and will therefore be deleted by the MessageLoop. Otherwise, we
|
| thread.cc | 15 // This task is used to trigger the message loop to exit.
16 class ThreadQuitTask : public Task {
|
| timer.h | 50 #include "base/task.h"
85 // We have access to the timer_ member so we can orphan this task.
86 class TimerTask : public Task {
98 // Used to initiated a new delayed task. This has the side-effect of
146 // This task may be getting cleared because the MessageLoop has been
148 // to this now-defunct task.
172 // Task is old. So, if the Timer points to a different task, assume
173 // that the Timer has already taken care of properly setting the task.
|
| /external/webkit/WebKit/chromium/src/ |
| WebWorkerBase.cpp | 141 void WebWorkerBase::dispatchTaskToMainThread(PassOwnPtr<ScriptExecutionContext::Task> task)
143 return callOnMainThread(invokeTaskMethod, task.release());
148 ScriptExecutionContext::Task* task = local
149 static_cast<ScriptExecutionContext::Task*>(param);
150 task->performTask(0);
151 delete task;
295 void WebWorkerBase::postTaskToLoader(PassOwnPtr<ScriptExecutionContext::Task> task)
[all...] |
| /sdk/anttasks/src/com/android/ant/ |
| AidlExecTask.java | 21 import org.apache.tools.ant.Task;
33 * Task to execute aidl.
44 public class AidlExecTask extends Task {
108 ExecTask task = new ExecTask(); local
109 task.setProject(taskProject);
110 task.setOwningTarget(getOwningTarget());
111 task.setExecutable(mExecutable);
112 task.setFailonerror(true);
114 task.createArg().setValue("-p" + mFramework);
115 task.createArg().setValue("-o" + mGenFolder)
[all...] |
| AaptExecLoopTask.java | 21 import org.apache.tools.ant.Task;
29 * Task to execute aapt.
31 * <p>It does not follow the exec task format, instead it has its own parameters, which maps
35 * <p>The following map shows how to use the task for each supported aapt command line
54 public final class AaptExecLoopTask extends Task {
57 * Class representing a <nocompress> node in the main task XML.
268 * @see org.apache.tools.ant.Task#execute()
318 // create a task for the default apk.
319 ExecTask task = new ExecTask(); local
320 task.setExecutable(mExecutable)
[all...] |
| ApkBuilderTask.java | 26 import org.apache.tools.ant.Task;
34 public class ApkBuilderTask extends Task {
220 // this shouldn't happen since setup task is the one setting up every time.
|
| /external/chromium/net/base/ |
| test_completion_callback_unittest.cc | 66 Task* reply = NewRunnableMethod(this, &ExampleWorker::DoCallback);
|
| cert_verifier.cc | 52 Task* reply = NewRunnableMethod(this, &Request::DoCallback);
|
| directory_lister.cc | 20 class DirectoryDataEvent : public Task {
|
| /external/webkit/WebCore/workers/ |
| GenericWorkerTask.h | 67 class GenericWorkerTask1 : public ScriptExecutionContext::Task {
96 class GenericWorkerTask2 : public ScriptExecutionContext::Task {
128 class GenericWorkerTask3 : public ScriptExecutionContext::Task {
163 class GenericWorkerTask4 : public ScriptExecutionContext::Task {
201 class GenericWorkerTask5 : public ScriptExecutionContext::Task {
242 class GenericWorkerTask6 : public ScriptExecutionContext::Task {
286 class GenericWorkerTask7 : public ScriptExecutionContext::Task {
333 class GenericWorkerTask8 : public ScriptExecutionContext::Task {
383 PassOwnPtr<ScriptExecutionContext::Task> createCallbackTask(
393 PassOwnPtr<ScriptExecutionContext::Task> createCallbackTask
[all...] |
| WorkerThread.cpp | 157 class WorkerThreadShutdownFinishTask : public ScriptExecutionContext::Task {
174 class WorkerThreadShutdownStartTask : public ScriptExecutionContext::Task {
|
| DefaultSharedWorkerRepository.cpp | 76 virtual void postTaskToLoader(PassOwnPtr<ScriptExecutionContext::Task>);
77 virtual void postTaskForModeToWorkerContext(PassOwnPtr<ScriptExecutionContext::Task>, const String&);
131 void SharedWorkerProxy::postTaskToLoader(PassOwnPtr<ScriptExecutionContext::Task> task)
144 document->postTask(task);
147 void SharedWorkerProxy::postTaskForModeToWorkerContext(PassOwnPtr<ScriptExecutionContext::Task> task, const String& mode)
152 m_thread->runLoop().postTaskForMode(task, mode);
222 class SharedWorkerConnectTask : public ScriptExecutionContext::Task {
|
| WorkerContext.h | 80 virtual void postTask(PassOwnPtr<Task>); // Executes the task on context's thread asynchronously.
|
| /external/webkit/WebCore/dom/ |
| ScriptExecutionContext.cpp | 47 class ProcessMessagesSoonTask : public ScriptExecutionContext::Task {
264 ScriptExecutionContext::Task::~Task()
|
| /external/chromium/net/disk_cache/ |
| stress_cache.cc | 135 class CrashTask : public Task {
162 CrashTask* task = new CrashTask(); local
163 target_loop->PostDelayedTask(FROM_HERE, task, task_delay);
|
| /external/qemu/distrib/sdl-1.2.12/src/thread/amigaos/ |
| SDL_thread.c | 159 struct Task *wait;
|
