Mojo: Armed Watchers

mojo/public/cpp/system/watcher.cc

 // Copyright 2016 The Chromium 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 "mojo/public/cpp/system/watcher.h"
 
 #include "base/bind.h"
 #include "base/location.h"
 #include "base/macros.h"
 #include "base/trace_event/heap_profiler.h"
 #include "mojo/public/c/system/functions.h"
 
 namespace mojo {
 
 Watcher::Watcher(const tracked_objects::Location& from_here,
+                 ArmingPolicy arming_policy,
                  scoped_refptr<base::SingleThreadTaskRunner> runner)
-    : task_runner_(std::move(runner)),
+    : arming_policy_(arming_policy),
+      task_runner_(std::move(runner)),
       is_default_task_runner_(task_runner_ ==
                               base::ThreadTaskRunnerHandle::Get()),
       heap_profiler_tag_(from_here.file_name()),
       weak_factory_(this) {
   DCHECK(task_runner_->BelongsToCurrentThread());
   weak_self_ = weak_factory_.GetWeakPtr();
 }
 
 Watcher::~Watcher() {
   if(IsWatching())
     Cancel();
+
+  if (was_deleted_flag_)
+    *was_deleted_flag_ = true;
 }
 
 bool Watcher::IsWatching() const {
   DCHECK(thread_checker_.CalledOnValidThread());
   return handle_.is_valid();
 }
 
 MojoResult Watcher::Start(Handle handle,
                           MojoHandleSignals signals,
                           const ReadyCallback& callback) {
   DCHECK(thread_checker_.CalledOnValidThread());
   DCHECK(!IsWatching());
   DCHECK(!callback.is_null());
 
   callback_ = callback;
   handle_ = handle;
-  MojoResult result = MojoWatch(handle_.value(), signals,
-                                &Watcher::CallOnHandleReady,
-                                reinterpret_cast<uintptr_t>(this));
+  MojoResult result =
+      MojoRegisterWatcher(handle_.value(), signals, &Watcher::CallOnHandleReady,
+                          reinterpret_cast<uintptr_t>(this));
   if (result != MOJO_RESULT_OK) {
     handle_.set_value(kInvalidHandleValue);
     callback_.Reset();
     DCHECK(result == MOJO_RESULT_FAILED_PRECONDITION ||
            result == MOJO_RESULT_INVALID_ARGUMENT);
     return result;
   }
 
+  if (arming_policy_ == ArmingPolicy::AUTOMATIC)
+    ArmOrNotify();
+
   return MOJO_RESULT_OK;
 }
 
 void Watcher::Cancel() {
   DCHECK(thread_checker_.CalledOnValidThread());
 
-  // The watch may have already been cancelled if the handle was closed.
+  // The watcher may have already been cancelled if the handle was closed.
   if (!handle_.is_valid())
     return;
 
   MojoResult result =
-      MojoCancelWatch(handle_.value(), reinterpret_cast<uintptr_t>(this));
+      MojoUnregisterWatcher(handle_.value(), reinterpret_cast<uintptr_t>(this));
   // |result| may be MOJO_RESULT_INVALID_ARGUMENT if |handle_| has closed, but
   // OnHandleReady has not yet been called.
   DCHECK(result == MOJO_RESULT_INVALID_ARGUMENT || result == MOJO_RESULT_OK);
   handle_.set_value(kInvalidHandleValue);
   callback_.Reset();
 }
 
+MojoResult Watcher::Arm() {
+  DCHECK(thread_checker_.CalledOnValidThread());
+  return MojoArmWatcher(handle_.value(), reinterpret_cast<uintptr_t>(this));
+}
+
+void Watcher::ArmOrNotify() {
+  DCHECK(thread_checker_.CalledOnValidThread());
+
+  // Already cancelled, nothing to do.
+  if (!IsWatching())
+    return;
+
+  MojoResult result = Arm();
+  switch (result) {
+    case MOJO_RESULT_OK:
+      // We're armed. Nothing else to do.
+      return;
+    case MOJO_RESULT_ALREADY_EXISTS:
+      // Signals are already satisfied. We post a notification of success.
+      result = MOJO_RESULT_OK;
+      break;
+    case MOJO_RESULT_FAILED_PRECONDITION:
+      // Signals are unsatisfiable. We post a notification to indicate this.
+      break;
+    default:
+      NOTREACHED();
+      return;
+  }
+
+  task_runner_->PostTask(
+      FROM_HERE, base::Bind(&Watcher::OnHandleReady, weak_self_, result));
+}
+
 void Watcher::OnHandleReady(MojoResult result) {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   ReadyCallback callback = callback_;
   if (result == MOJO_RESULT_CANCELLED) {
     handle_.set_value(kInvalidHandleValue);
     callback_.Reset();
   }
 
   // NOTE: It's legal for |callback| to delete |this|.
   if (!callback.is_null()) {
     TRACE_HEAP_PROFILER_API_SCOPED_TASK_EXECUTION event(heap_profiler_tag_);
+
+    bool was_deleted = false;
+    was_deleted_flag_ = &was_deleted;
     callback.Run(result);
+    if (was_deleted)
+      return;
+    was_deleted_flag_ = nullptr;
+    if (arming_policy_ == ArmingPolicy::AUTOMATIC && IsWatching())
+      ArmOrNotify();
   }
 }
 
+void Watcher::OnHandleReadyFromAnyThread(MojoResult result,
+                                         MojoWatchNotificationFlags flags) {
+  if ((flags & MOJO_WATCH_NOTIFICATION_FLAG_FROM_SYSTEM) &&
+      task_runner_->RunsTasksOnCurrentThread() && is_default_task_runner_) {
+    // System notifications will trigger from the task runner passed to
+    // mojo::edk::InitIPCSupport(). In Chrome this happens to always be the
+    // default task runner for the IO thread.
+    OnHandleReady(result);
+  } else {
+    task_runner_->PostTask(
+        FROM_HERE, base::Bind(&Watcher::OnHandleReady, weak_self_, result));
+  }
+}
+
 // static
 void Watcher::CallOnHandleReady(uintptr_t context,
                                 MojoResult result,
                                 MojoHandleSignalsState signals_state,
                                 MojoWatchNotificationFlags flags) {
   // NOTE: It is safe to assume the Watcher still exists because this callback
   // will never be run after the Watcher's destructor.
   //
   // TODO: Maybe we should also expose |signals_state| through the Watcher API.
-  // Current HandleWatcher users have no need for it, so it's omitted here.
-  Watcher* watcher = reinterpret_cast<Watcher*>(context);
-
-  if ((flags & MOJO_WATCH_NOTIFICATION_FLAG_FROM_SYSTEM) &&
-      watcher->task_runner_->RunsTasksOnCurrentThread() &&
-      watcher->is_default_task_runner_) {
-    // System notifications will trigger from the task runner passed to
-    // mojo::edk::InitIPCSupport(). In Chrome this happens to always be the
-    // default task runner for the IO thread.
-    watcher->OnHandleReady(result);
-  } else {
-    watcher->task_runner_->PostTask(
-        FROM_HERE,
-        base::Bind(&Watcher::OnHandleReady, watcher->weak_self_, result));
-  }
+  // Current users have no need for it, so it's omitted here.
+  auto* watcher = reinterpret_cast<Watcher*>(context);
+  watcher->OnHandleReadyFromAnyThread(result, flags);
 }
 
 }  // namespace mojo