Update mojo sdk to rev 3d23dae011859a2aae49f1d1adde705c8e85d819

ipc/mojo/scoped_ipc_support.cc

+// Copyright 2015 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 "ipc/mojo/scoped_ipc_support.h"
+
+#include "base/bind.h"
+#include "base/lazy_instance.h"
+#include "base/logging.h"
+#include "base/message_loop/message_loop.h"
+#include "base/synchronization/condition_variable.h"
+#include "base/synchronization/lock.h"
+#include "base/synchronization/waitable_event.h"
+#include "third_party/mojo/src/mojo/edk/embedder/embedder.h"
+#include "third_party/mojo/src/mojo/edk/embedder/process_delegate.h"
+
+namespace IPC {
+
+namespace {
+
+class IPCSupportInitializer : public mojo::embedder::ProcessDelegate {
+ public:
+  IPCSupportInitializer()
+      : init_count_(0),
+        shutting_down_(false) {
+  }
+
+  ~IPCSupportInitializer() override {}
+
+  void Init(scoped_refptr<base::TaskRunner> io_thread_task_runner) {
+    base::AutoLock locker(lock_);
+    DCHECK((init_count_ == 0 && !io_thread_task_runner_) ||
+           io_thread_task_runner_ == io_thread_task_runner);
+
+    if (shutting_down_) {
+      // If reinitialized before a pending shutdown task is executed, we
+      // effectively cancel the shutdown task.
+      DCHECK(init_count_ == 1);
+      shutting_down_ = false;
+      return;
+    }
+
+    init_count_++;
+    if (init_count_ == 1) {
+      io_thread_task_runner_ = io_thread_task_runner;
+      mojo::embedder::InitIPCSupport(mojo::embedder::ProcessType::NONE,
+                                     io_thread_task_runner_,
+                                     this, io_thread_task_runner_,
+                                     mojo::embedder::ScopedPlatformHandle());
+    }
+  }
+
+  void ShutDown() {
+    base::AutoLock locker(lock_);
+    DCHECK(init_count_ > 0);
+    DCHECK(!shutting_down_);
+
+    if (init_count_ > 1) {
+      init_count_--;
+      return;
+    }
+
+    shutting_down_ = true;
+    if (base::MessageLoop::current() &&
+        base::MessageLoop::current()->task_runner() == io_thread_task_runner_) {
+      base::AutoUnlock unlocker_(lock_);
+      ShutDownOnIOThread();
+    } else {
+      io_thread_task_runner_->PostTask(
+          FROM_HERE,
+          base::Bind(&IPCSupportInitializer::ShutDownOnIOThread,
+                     base::Unretained(this)));
+    }
+  }
+
+ private:
+  void ShutDownOnIOThread() {
+    base::AutoLock locker(lock_);
+    if (shutting_down_) {
+      DCHECK(init_count_ == 1);
+      mojo::embedder::ShutdownIPCSupportOnIOThread();
+      init_count_ = 0;
+      shutting_down_ = false;
+      io_thread_task_runner_ = nullptr;
+   }
+  }
+
+  void OnShutdownComplete() override {}
+
+  base::Lock lock_;
+  size_t init_count_;
+  bool shutting_down_;
+
+  scoped_refptr<base::TaskRunner> io_thread_task_runner_;
+
+  DISALLOW_COPY_AND_ASSIGN(IPCSupportInitializer);
+};
+
+base::LazyInstance<IPCSupportInitializer>::Leaky ipc_support_initializer;
+
+}  // namespace
+
+ScopedIPCSupport::ScopedIPCSupport(
+    scoped_refptr<base::TaskRunner> io_thread_task_runner) {
+  ipc_support_initializer.Get().Init(io_thread_task_runner);
+}
+
+ScopedIPCSupport::~ScopedIPCSupport() {
+  ipc_support_initializer.Get().ShutDown();
+}
+
+}  // namespace IPC