[mojo] Delete third_party/mojo

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 <stddef.h>
 
 #include "base/bind.h"
 #include "base/lazy_instance.h"
 #include "base/logging.h"
 #include "base/macros.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 "base/thread_task_runner_handle.h"
-#include "third_party/mojo/src/mojo/edk/embedder/embedder.h"
-#include "third_party/mojo/src/mojo/edk/embedder/process_delegate.h"
+#include "mojo/edk/embedder/embedder.h"
+#include "mojo/edk/embedder/process_delegate.h"
 
 namespace IPC {
 
 namespace {
-// TODO(use_chrome_edk)
-//class IPCSupportInitializer : public mojo::edk::ProcessDelegate {
-class IPCSupportInitializer : public mojo::embedder::ProcessDelegate {
+class IPCSupportInitializer : public mojo::edk::ProcessDelegate {
  public:
   IPCSupportInitializer()
       : init_count_(0),
         shutting_down_(false),
         was_shut_down_(false),
         observer_(nullptr) {}
 
   ~IPCSupportInitializer() override { DCHECK(!observer_); }
 
   void Init(scoped_refptr<base::TaskRunner> io_thread_task_runner);
@@ skipping 18 matching lines @@
       initializer_->ShutDown(true);
     }
 
     IPCSupportInitializer* initializer_;
 
     DISALLOW_COPY_AND_ASSIGN(MessageLoopObserver);
   };
 
   void ShutDownOnIOThread();
 
-  // mojo::embedder::ProcessDelegate:
+  // mojo::edk::ProcessDelegate:
   void OnShutdownComplete() override {}
 
   static void WatchMessageLoopOnIOThread(MessageLoopObserver* observer);
 
   base::Lock lock_;
   size_t init_count_;
   bool shutting_down_;
 
   // This is used to track whether shutdown has occurred yet, since we can be
   // shut down by either the scoper or IO MessageLoop destruction.
@@ skipping 23 matching lines @@
     return;
   }
 
   init_count_++;
   if (init_count_ == 1) {
     was_shut_down_ = false;
     observer_ = new MessageLoopObserver(this);
     io_thread_task_runner_ = io_thread_task_runner;
     io_thread_task_runner_->PostTask(
         FROM_HERE, base::Bind(&WatchMessageLoopOnIOThread, observer_));
-    mojo::embedder::InitIPCSupport(
-        mojo::embedder::ProcessType::NONE, this, io_thread_task_runner_,
-        mojo::embedder::ScopedPlatformHandle());
+    mojo::edk::InitIPCSupport(this, io_thread_task_runner_);
   }
 }
 
 void IPCSupportInitializer::ShutDown(bool force) {
   base::AutoLock locker(lock_);
   if (shutting_down_ || was_shut_down_)
     return;
   DCHECK(init_count_ > 0);
   if (init_count_ > 1 && !force) {
     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)));
   }
 }
 
 void IPCSupportInitializer::ShutDownOnIOThread() {
   base::AutoLock locker(lock_);
   if (shutting_down_ && !was_shut_down_) {
-    mojo::embedder::ShutdownIPCSupportOnIOThread();
+    mojo::edk::ShutdownIPCSupportOnIOThread();
     init_count_ = 0;
     shutting_down_ = false;
     io_thread_task_runner_ = nullptr;
     was_shut_down_ = true;
     if (observer_) {
       delete observer_;
       observer_ = nullptr;
     }
   }
 }
@@ skipping 11 matching lines @@
 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(false);
 }
 
 }  // namespace IPC