Move //mojo/{public, edk} underneath //third_party

This CL move //mojo/public and //mojo/edk to live in the following locations:
- //third_party/mojo/src/mojo/public
- //third_party/mojo/src/mojo/edk

It moves the related gypfiles from //mojo to //third_party/mojo and updates
them as necessary to account for the file moves. It also updates clients of the
mojo SDK and EDK targets in both GYP and GN. (Note that for GN, the mojo SDK
and EDK build systems are maintained in the Mojo repo and designed to be
flexible wrt the location of the SDK/EDK in a client repo, so no changes are
needed.

This CL does not update include paths to the code being moved to limit the
number of moving parts, instead relying on the include_dirs that the SDK and
EDK targets supply to their direct dependents to ensure that include paths
continue to resolve correctly.

NOPRESUBMIT=true

Review URL: https://codereview.chromium.org/814543006

Cr-Commit-Position: refs/heads/master@{#312129}

4 files changed, 0 insertions, 821 deletions

diff --git a/mojo/public/cpp/utility/tests/BUILD.gn b/mojo/public/cpp/utility/tests/BUILD.gn
deleted file mode 100644
index a8a96c1..0000000
--- a/mojo/public/cpp/utility/tests/BUILD.gn
+++ /dev/null
@@ -1,31 +0,0 @@
-# Copyright 2014 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.
-
-import("../../../mojo_sdk.gni")
-
-mojo_sdk_source_set("tests") {
-  testonly = true
-
-  sources = [
-    "run_loop_unittest.cc",
-  ]
-
-  deps = [
-    "//testing/gtest",
-  ]
-
-  mojo_sdk_deps = [
-    "mojo/public/cpp/system",
-    "mojo/public/cpp/test_support:test_utils",
-    "mojo/public/cpp/utility",
-  ]
-
-  # crbug.com/342893
-  if (!is_win) {
-    sources += [
-      "mutex_unittest.cc",
-      "thread_unittest.cc",
-    ]
-  }
-}
diff --git a/mojo/public/cpp/utility/tests/mutex_unittest.cc b/mojo/public/cpp/utility/tests/mutex_unittest.cc
deleted file mode 100644
index 78e95c5..0000000
--- a/mojo/public/cpp/utility/tests/mutex_unittest.cc
+++ /dev/null
@@ -1,259 +0,0 @@
-// Copyright 2014 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/utility/mutex.h"
-
-#include <stdlib.h>  // For |rand()|.
-#include <time.h>  // For |nanosleep()| (defined by POSIX).
-
-#include <vector>
-
-#include "mojo/public/cpp/system/macros.h"
-#include "mojo/public/cpp/utility/thread.h"
-#include "testing/gtest/include/gtest/gtest.h"
-
-namespace mojo {
-namespace {
-
-TEST(MutexTest, TrivialSingleThreaded) {
-  Mutex mutex;
-
-  mutex.Lock();
-  mutex.AssertHeld();
-  mutex.Unlock();
-
-  EXPECT_TRUE(mutex.TryLock());
-  mutex.AssertHeld();
-  mutex.Unlock();
-
-  {
-    MutexLock lock(&mutex);
-    mutex.AssertHeld();
-  }
-
-  EXPECT_TRUE(mutex.TryLock());
-  mutex.Unlock();
-}
-
-class Fiddler {
- public:
-  enum Type { kTypeLock, kTypeTry };
-  Fiddler(size_t times_to_lock,
-          Type type,
-          bool should_sleep,
-          Mutex* mutex,
-          int* shared_value)
-      : times_to_lock_(times_to_lock),
-        type_(type),
-        should_sleep_(should_sleep),
-        mutex_(mutex),
-        shared_value_(shared_value) {
-  }
-
-  ~Fiddler() {
-  }
-
-  void Fiddle() {
-    for (size_t i = 0; i < times_to_lock_;) {
-      switch (type_) {
-        case kTypeLock: {
-          mutex_->Lock();
-          int old_shared_value = *shared_value_;
-          if (should_sleep_)
-            SleepALittle();
-          *shared_value_ = old_shared_value + 1;
-          mutex_->Unlock();
-          i++;
-          break;
-        }
-        case kTypeTry:
-          if (mutex_->TryLock()) {
-            int old_shared_value = *shared_value_;
-            if (should_sleep_)
-              SleepALittle();
-            *shared_value_ = old_shared_value + 1;
-            mutex_->Unlock();
-            i++;
-          } else {
-            SleepALittle();  // Don't spin.
-          }
-          break;
-      }
-    }
-  }
-
- private:
-  static void SleepALittle() {
-    static const long kNanosPerMilli = 1000000;
-    struct timespec req = {
-      0,  // Seconds.
-      (rand() % 10) * kNanosPerMilli // Nanoseconds.
-    };
-    int rv = nanosleep(&req, nullptr);
-    MOJO_ALLOW_UNUSED_LOCAL(rv);
-    assert(rv == 0);
-  }
-
-  const size_t times_to_lock_;
-  const Type type_;
-  const bool should_sleep_;
-  Mutex* const mutex_;
-  int* const shared_value_;
-
-  MOJO_DISALLOW_COPY_AND_ASSIGN(Fiddler);
-};
-
-class FiddlerThread : public Thread {
- public:
-  // Takes ownership of |fiddler|.
-  FiddlerThread(Fiddler* fiddler)
-      : fiddler_(fiddler) {
-  }
-
-  ~FiddlerThread() override { delete fiddler_; }
-
-  void Run() override { fiddler_->Fiddle(); }
-
- private:
-  Fiddler* const fiddler_;
-
-  MOJO_DISALLOW_COPY_AND_ASSIGN(FiddlerThread);
-};
-
-// This does a stress test (that also checks exclusion).
-TEST(MutexTest, ThreadedStress) {
-  static const size_t kNumThreads = 20;
-  static const int kTimesToLockEach = 20;
-  assert(kNumThreads % 4 == 0);
-
-  Mutex mutex;
-  int shared_value = 0;
-
-  std::vector<FiddlerThread*> fiddler_threads;
-
-  for (size_t i = 0; i < kNumThreads; i += 4) {
-    fiddler_threads.push_back(new FiddlerThread(new Fiddler(
-        kTimesToLockEach, Fiddler::kTypeLock, false, &mutex, &shared_value)));
-    fiddler_threads.push_back(new FiddlerThread(new Fiddler(
-        kTimesToLockEach, Fiddler::kTypeTry, false, &mutex, &shared_value)));
-    fiddler_threads.push_back(new FiddlerThread(new Fiddler(
-        kTimesToLockEach, Fiddler::kTypeLock, true, &mutex, &shared_value)));
-    fiddler_threads.push_back(new FiddlerThread(new Fiddler(
-        kTimesToLockEach, Fiddler::kTypeTry, true, &mutex, &shared_value)));
-  }
-
-  for (size_t i = 0; i < kNumThreads; i++)
-    fiddler_threads[i]->Start();
-
-  // Do some fiddling ourselves.
-  Fiddler(kTimesToLockEach, Fiddler::kTypeLock, true, &mutex, &shared_value)
-      .Fiddle();
-
-  // Join.
-  for (size_t i = 0; i < kNumThreads; i++)
-    fiddler_threads[i]->Join();
-
-  EXPECT_EQ(static_cast<int>(kNumThreads + 1) * kTimesToLockEach, shared_value);
-
-  // Delete.
-  for (size_t i = 0; i < kNumThreads; i++)
-    delete fiddler_threads[i];
-  fiddler_threads.clear();
-}
-
-class TryThread : public Thread {
- public:
-  explicit TryThread(Mutex* mutex) : mutex_(mutex), try_lock_succeeded_() {}
-  ~TryThread() override {}
-
-  void Run() override {
-    try_lock_succeeded_ = mutex_->TryLock();
-    if (try_lock_succeeded_)
-      mutex_->Unlock();
-  }
-
-  bool try_lock_succeeded() const { return try_lock_succeeded_; }
-
- private:
-  Mutex* const mutex_;
-  bool try_lock_succeeded_;
-
-  MOJO_DISALLOW_COPY_AND_ASSIGN(TryThread);
-};
-
-TEST(MutexTest, TryLock) {
-  Mutex mutex;
-
-  // |TryLock()| should succeed -- we don't have the lock.
-  {
-    TryThread thread(&mutex);
-    thread.Start();
-    thread.Join();
-    EXPECT_TRUE(thread.try_lock_succeeded());
-  }
-
-  // Take the lock.
-  ASSERT_TRUE(mutex.TryLock());
-
-  // Now it should fail.
-  {
-    TryThread thread(&mutex);
-    thread.Start();
-    thread.Join();
-    EXPECT_FALSE(thread.try_lock_succeeded());
-  }
-
-  // Release the lock.
-  mutex.Unlock();
-
-  // It should succeed again.
-  {
-    TryThread thread(&mutex);
-    thread.Start();
-    thread.Join();
-    EXPECT_TRUE(thread.try_lock_succeeded());
-  }
-}
-
-
-// Tests of assertions for Debug builds.
-#if !defined(NDEBUG)
-// Test |AssertHeld()| (which is an actual user API).
-TEST(MutexTest, DebugAssertHeldFailure) {
-  Mutex mutex;
-  EXPECT_DEATH_IF_SUPPORTED(mutex.AssertHeld(), "");
-}
-
-// Test other consistency checks.
-TEST(MutexTest, DebugAssertionFailures) {
-  // Unlock without lock held.
-  EXPECT_DEATH_IF_SUPPORTED({
-    Mutex mutex;
-    mutex.Unlock();
-  }, "");
-
-  // Lock with lock held (on same thread).
-  EXPECT_DEATH_IF_SUPPORTED({
-    Mutex mutex;
-    mutex.Lock();
-    mutex.Lock();
-  }, "");
-
-  // Try lock with lock held.
-  EXPECT_DEATH_IF_SUPPORTED({
-    Mutex mutex;
-    mutex.Lock();
-    mutex.TryLock();
-  }, "");
-
-  // Destroy lock with lock held.
-  EXPECT_DEATH_IF_SUPPORTED({
-    Mutex mutex;
-    mutex.Lock();
-  }, "");
-}
-#endif  // !defined(NDEBUG)
-
-}  // namespace
-}  // namespace mojo
diff --git a/mojo/public/cpp/utility/tests/run_loop_unittest.cc b/mojo/public/cpp/utility/tests/run_loop_unittest.cc
deleted file mode 100644
index 4ab4876..0000000
--- a/mojo/public/cpp/utility/tests/run_loop_unittest.cc
+++ /dev/null
@@ -1,425 +0,0 @@
-// Copyright 2014 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/utility/run_loop.h"
-
-#include <string>
-
-#include "mojo/public/cpp/system/core.h"
-#include "mojo/public/cpp/test_support/test_utils.h"
-#include "mojo/public/cpp/utility/run_loop_handler.h"
-#include "testing/gtest/include/gtest/gtest.h"
-
-namespace mojo {
-namespace {
-
-class TestRunLoopHandler : public RunLoopHandler {
- public:
-  TestRunLoopHandler()
-      : ready_count_(0),
-        error_count_(0),
-        last_error_result_(MOJO_RESULT_OK) {
-  }
-  ~TestRunLoopHandler() override {}
-
-  void clear_ready_count() { ready_count_ = 0; }
-  int ready_count() const { return ready_count_; }
-
-  void clear_error_count() { error_count_ = 0; }
-  int error_count() const { return error_count_; }
-
-  MojoResult last_error_result() const { return last_error_result_; }
-
-  // RunLoopHandler:
-  void OnHandleReady(const Handle& handle) override { ready_count_++; }
-  void OnHandleError(const Handle& handle, MojoResult result) override {
-    error_count_++;
-    last_error_result_ = result;
-  }
-
- private:
-  int ready_count_;
-  int error_count_;
-  MojoResult last_error_result_;
-
-  MOJO_DISALLOW_COPY_AND_ASSIGN(TestRunLoopHandler);
-};
-
-class RunLoopTest : public testing::Test {
- public:
-  RunLoopTest() {}
-
-  void SetUp() override {
-    Test::SetUp();
-    RunLoop::SetUp();
-  }
-  void TearDown() override {
-    RunLoop::TearDown();
-    Test::TearDown();
-  }
-
- private:
-  MOJO_DISALLOW_COPY_AND_ASSIGN(RunLoopTest);
-};
-
-// Trivial test to verify Run() with no added handles returns.
-TEST_F(RunLoopTest, ExitsWithNoHandles) {
-  RunLoop run_loop;
-  run_loop.Run();
-}
-
-class RemoveOnReadyRunLoopHandler : public TestRunLoopHandler {
- public:
-  RemoveOnReadyRunLoopHandler() : run_loop_(nullptr) {}
-  ~RemoveOnReadyRunLoopHandler() override {}
-
-  void set_run_loop(RunLoop* run_loop) { run_loop_ = run_loop; }
-
-  // RunLoopHandler:
-  void OnHandleReady(const Handle& handle) override {
-    run_loop_->RemoveHandler(handle);
-    TestRunLoopHandler::OnHandleReady(handle);
-  }
-
- private:
-  RunLoop* run_loop_;
-
-  MOJO_DISALLOW_COPY_AND_ASSIGN(RemoveOnReadyRunLoopHandler);
-};
-
-// Verifies RunLoop quits when no more handles (handle is removed when ready).
-TEST_F(RunLoopTest, HandleReady) {
-  RemoveOnReadyRunLoopHandler handler;
-  MessagePipe test_pipe;
-  EXPECT_TRUE(test::WriteTextMessage(test_pipe.handle1.get(), std::string()));
-
-  RunLoop run_loop;
-  handler.set_run_loop(&run_loop);
-  run_loop.AddHandler(&handler, test_pipe.handle0.get(),
-                      MOJO_HANDLE_SIGNAL_READABLE, MOJO_DEADLINE_INDEFINITE);
-  run_loop.Run();
-  EXPECT_EQ(1, handler.ready_count());
-  EXPECT_EQ(0, handler.error_count());
-  EXPECT_FALSE(run_loop.HasHandler(test_pipe.handle0.get()));
-}
-
-class QuitOnReadyRunLoopHandler : public TestRunLoopHandler {
- public:
-  QuitOnReadyRunLoopHandler() : run_loop_(nullptr) {}
-  ~QuitOnReadyRunLoopHandler() override {}
-
-  void set_run_loop(RunLoop* run_loop) { run_loop_ = run_loop; }
-
-  // RunLoopHandler:
-  void OnHandleReady(const Handle& handle) override {
-    run_loop_->Quit();
-    TestRunLoopHandler::OnHandleReady(handle);
-  }
-
- private:
-  RunLoop* run_loop_;
-
-  MOJO_DISALLOW_COPY_AND_ASSIGN(QuitOnReadyRunLoopHandler);
-};
-
-// Verifies Quit() from OnHandleReady() quits the loop.
-TEST_F(RunLoopTest, QuitFromReady) {
-  QuitOnReadyRunLoopHandler handler;
-  MessagePipe test_pipe;
-  EXPECT_TRUE(test::WriteTextMessage(test_pipe.handle1.get(), std::string()));
-
-  RunLoop run_loop;
-  handler.set_run_loop(&run_loop);
-  run_loop.AddHandler(&handler, test_pipe.handle0.get(),
-                      MOJO_HANDLE_SIGNAL_READABLE, MOJO_DEADLINE_INDEFINITE);
-  run_loop.Run();
-  EXPECT_EQ(1, handler.ready_count());
-  EXPECT_EQ(0, handler.error_count());
-  EXPECT_TRUE(run_loop.HasHandler(test_pipe.handle0.get()));
-}
-
-class QuitOnErrorRunLoopHandler : public TestRunLoopHandler {
- public:
-  QuitOnErrorRunLoopHandler() : run_loop_(nullptr) {}
-  ~QuitOnErrorRunLoopHandler() override {}
-
-  void set_run_loop(RunLoop* run_loop) { run_loop_ = run_loop; }
-
-  // RunLoopHandler:
-  void OnHandleError(const Handle& handle, MojoResult result) override {
-    run_loop_->Quit();
-    TestRunLoopHandler::OnHandleError(handle, result);
-  }
-
- private:
-  RunLoop* run_loop_;
-
-  MOJO_DISALLOW_COPY_AND_ASSIGN(QuitOnErrorRunLoopHandler);
-};
-
-// Verifies Quit() when the deadline is reached works.
-TEST_F(RunLoopTest, QuitWhenDeadlineExpired) {
-  QuitOnErrorRunLoopHandler handler;
-  MessagePipe test_pipe;
-  RunLoop run_loop;
-  handler.set_run_loop(&run_loop);
-  run_loop.AddHandler(&handler, test_pipe.handle0.get(),
-                      MOJO_HANDLE_SIGNAL_READABLE,
-                      static_cast<MojoDeadline>(10000));
-  run_loop.Run();
-  EXPECT_EQ(0, handler.ready_count());
-  EXPECT_EQ(1, handler.error_count());
-  EXPECT_EQ(MOJO_RESULT_DEADLINE_EXCEEDED, handler.last_error_result());
-  EXPECT_FALSE(run_loop.HasHandler(test_pipe.handle0.get()));
-}
-
-// Test that handlers are notified of loop destruction.
-TEST_F(RunLoopTest, Destruction) {
-  TestRunLoopHandler handler;
-  MessagePipe test_pipe;
-  {
-    RunLoop run_loop;
-    run_loop.AddHandler(&handler,
-                        test_pipe.handle0.get(),
-                        MOJO_HANDLE_SIGNAL_READABLE,
-                        MOJO_DEADLINE_INDEFINITE);
-  }
-  EXPECT_EQ(1, handler.error_count());
-  EXPECT_EQ(MOJO_RESULT_ABORTED, handler.last_error_result());
-}
-
-class RemoveManyRunLoopHandler : public TestRunLoopHandler {
- public:
-  RemoveManyRunLoopHandler() : run_loop_(nullptr) {}
-  ~RemoveManyRunLoopHandler() override {}
-
-  void set_run_loop(RunLoop* run_loop) { run_loop_ = run_loop; }
-  void add_handle(const Handle& handle) { handles_.push_back(handle); }
-
-  // RunLoopHandler:
-  void OnHandleError(const Handle& handle, MojoResult result) override {
-    for (size_t i = 0; i < handles_.size(); i++)
-      run_loop_->RemoveHandler(handles_[i]);
-    TestRunLoopHandler::OnHandleError(handle, result);
-  }
-
- private:
-  std::vector<Handle> handles_;
-  RunLoop* run_loop_;
-
-  MOJO_DISALLOW_COPY_AND_ASSIGN(RemoveManyRunLoopHandler);
-};
-
-// Test that handlers are notified of loop destruction.
-TEST_F(RunLoopTest, MultipleHandleDestruction) {
-  RemoveManyRunLoopHandler odd_handler;
-  TestRunLoopHandler even_handler;
-  MessagePipe test_pipe1, test_pipe2, test_pipe3;
-  {
-    RunLoop run_loop;
-    odd_handler.set_run_loop(&run_loop);
-    odd_handler.add_handle(test_pipe1.handle0.get());
-    odd_handler.add_handle(test_pipe3.handle0.get());
-    run_loop.AddHandler(&odd_handler,
-                        test_pipe1.handle0.get(),
-                        MOJO_HANDLE_SIGNAL_READABLE,
-                        MOJO_DEADLINE_INDEFINITE);
-    run_loop.AddHandler(&even_handler,
-                        test_pipe2.handle0.get(),
-                        MOJO_HANDLE_SIGNAL_READABLE,
-                        MOJO_DEADLINE_INDEFINITE);
-    run_loop.AddHandler(&odd_handler,
-                        test_pipe3.handle0.get(),
-                        MOJO_HANDLE_SIGNAL_READABLE,
-                        MOJO_DEADLINE_INDEFINITE);
-  }
-  EXPECT_EQ(1, odd_handler.error_count());
-  EXPECT_EQ(1, even_handler.error_count());
-  EXPECT_EQ(MOJO_RESULT_ABORTED, odd_handler.last_error_result());
-  EXPECT_EQ(MOJO_RESULT_ABORTED, even_handler.last_error_result());
-}
-
-class AddHandlerOnErrorHandler : public TestRunLoopHandler {
- public:
-  AddHandlerOnErrorHandler() : run_loop_(nullptr) {}
-  ~AddHandlerOnErrorHandler() override {}
-
-  void set_run_loop(RunLoop* run_loop) { run_loop_ = run_loop; }
-
-  // RunLoopHandler:
-  void OnHandleError(const Handle& handle, MojoResult result) override {
-    run_loop_->AddHandler(this, handle,
-                          MOJO_HANDLE_SIGNAL_READABLE,
-                          MOJO_DEADLINE_INDEFINITE);
-    TestRunLoopHandler::OnHandleError(handle, result);
-  }
-
- private:
-  RunLoop* run_loop_;
-
-  MOJO_DISALLOW_COPY_AND_ASSIGN(AddHandlerOnErrorHandler);
-};
-
-TEST_F(RunLoopTest, AddHandlerOnError) {
-  AddHandlerOnErrorHandler handler;
-  MessagePipe test_pipe;
-  {
-    RunLoop run_loop;
-    handler.set_run_loop(&run_loop);
-    run_loop.AddHandler(&handler,
-                        test_pipe.handle0.get(),
-                        MOJO_HANDLE_SIGNAL_READABLE,
-                        MOJO_DEADLINE_INDEFINITE);
-  }
-  EXPECT_EQ(1, handler.error_count());
-  EXPECT_EQ(MOJO_RESULT_ABORTED, handler.last_error_result());
-}
-
-TEST_F(RunLoopTest, Current) {
-  EXPECT_TRUE(RunLoop::current() == nullptr);
-  {
-    RunLoop run_loop;
-    EXPECT_EQ(&run_loop, RunLoop::current());
-  }
-  EXPECT_TRUE(RunLoop::current() == nullptr);
-}
-
-class NestingRunLoopHandler : public TestRunLoopHandler {
- public:
-  static const size_t kDepthLimit;
-  static const char kSignalMagic;
-
-  NestingRunLoopHandler()
-      : run_loop_(nullptr),
-        pipe_(nullptr),
-        depth_(0),
-        reached_depth_limit_(false) {}
-
-  ~NestingRunLoopHandler() override {}
-
-  void set_run_loop(RunLoop* run_loop) { run_loop_ = run_loop; }
-  void set_pipe(MessagePipe* pipe) { pipe_ = pipe; }
-  bool reached_depth_limit() const { return reached_depth_limit_; }
-
-  // RunLoopHandler:
-  void OnHandleReady(const Handle& handle) override {
-    TestRunLoopHandler::OnHandleReady(handle);
-    EXPECT_EQ(handle.value(), pipe_->handle0.get().value());
-
-    ReadSignal();
-    size_t current_depth = ++depth_;
-    if (current_depth < kDepthLimit) {
-      WriteSignal();
-      run_loop_->Run();
-      if (current_depth == kDepthLimit - 1) {
-        // The topmost loop Quit()-ed, so its parent takes back the
-        // control without exeeding deadline.
-        EXPECT_EQ(error_count(), 0);
-      } else {
-        EXPECT_EQ(error_count(), 1);
-      }
-
-    } else {
-      EXPECT_EQ(current_depth, kDepthLimit);
-      reached_depth_limit_ = true;
-      run_loop_->Quit();
-    }
-    --depth_;
-  }
-
-  void WriteSignal() {
-    char write_byte = kSignalMagic;
-    MojoResult write_result =
-        WriteMessageRaw(pipe_->handle1.get(), &write_byte, 1, nullptr, 0,
-                        MOJO_WRITE_MESSAGE_FLAG_NONE);
-    EXPECT_EQ(write_result, MOJO_RESULT_OK);
-  }
-
-  void ReadSignal() {
-    char read_byte = 0;
-    uint32_t bytes_read = 1;
-    uint32_t handles_read = 0;
-    MojoResult read_result =
-        ReadMessageRaw(pipe_->handle0.get(), &read_byte, &bytes_read, nullptr,
-                       &handles_read, MOJO_READ_MESSAGE_FLAG_NONE);
-    EXPECT_EQ(read_result, MOJO_RESULT_OK);
-    EXPECT_EQ(read_byte, kSignalMagic);
-  }
-
- private:
-  RunLoop* run_loop_;
-  MessagePipe* pipe_;
-  size_t depth_;
-  bool reached_depth_limit_;
-
-  MOJO_DISALLOW_COPY_AND_ASSIGN(NestingRunLoopHandler);
-};
-
-const size_t NestingRunLoopHandler::kDepthLimit = 10;
-const char NestingRunLoopHandler::kSignalMagic = 'X';
-
-TEST_F(RunLoopTest, NestedRun) {
-  NestingRunLoopHandler handler;
-  MessagePipe test_pipe;
-  RunLoop run_loop;
-  handler.set_run_loop(&run_loop);
-  handler.set_pipe(&test_pipe);
-  run_loop.AddHandler(&handler, test_pipe.handle0.get(),
-                      MOJO_HANDLE_SIGNAL_READABLE,
-                      static_cast<MojoDeadline>(10000));
-  handler.WriteSignal();
-  run_loop.Run();
-
-  EXPECT_TRUE(handler.reached_depth_limit());
-  // Got MOJO_RESULT_DEADLINE_EXCEEDED once then removed from the
-  // RunLoop's handler list.
-  EXPECT_EQ(handler.error_count(), 1);
-  EXPECT_EQ(handler.last_error_result(), MOJO_RESULT_DEADLINE_EXCEEDED);
-}
-
-struct Task {
-  Task(int num, std::vector<int>* sequence) : num(num), sequence(sequence) {}
-
-  void Run() const { sequence->push_back(num); }
-
-  int num;
-  std::vector<int>* sequence;
-};
-
-TEST_F(RunLoopTest, DelayedTaskOrder) {
-  std::vector<int> sequence;
-  RunLoop run_loop;
-  run_loop.PostDelayedTask(Closure(Task(1, &sequence)), 0);
-  run_loop.PostDelayedTask(Closure(Task(2, &sequence)), 0);
-  run_loop.PostDelayedTask(Closure(Task(3, &sequence)), 0);
-  run_loop.RunUntilIdle();
-
-  ASSERT_EQ(3u, sequence.size());
-  EXPECT_EQ(1, sequence[0]);
-  EXPECT_EQ(2, sequence[1]);
-  EXPECT_EQ(3, sequence[2]);
-}
-
-struct QuittingTask {
-  explicit QuittingTask(RunLoop* run_loop) : run_loop(run_loop) {}
-
-  void Run() const { run_loop->Quit(); }
-
-  RunLoop* run_loop;
-};
-
-TEST_F(RunLoopTest, QuitFromDelayedTask) {
-  TestRunLoopHandler handler;
-  MessagePipe test_pipe;
-  RunLoop run_loop;
-  run_loop.AddHandler(&handler,
-                      test_pipe.handle0.get(),
-                      MOJO_HANDLE_SIGNAL_READABLE,
-                      MOJO_DEADLINE_INDEFINITE);
-  run_loop.PostDelayedTask(Closure(QuittingTask(&run_loop)), 0);
-  run_loop.Run();
-}
-
-}  // namespace
-}  // namespace mojo
diff --git a/mojo/public/cpp/utility/tests/thread_unittest.cc b/mojo/public/cpp/utility/tests/thread_unittest.cc
deleted file mode 100644
index 57c4ad9..0000000
--- a/mojo/public/cpp/utility/tests/thread_unittest.cc
+++ /dev/null
@@ -1,106 +0,0 @@
-// Copyright 2014 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/utility/thread.h"
-
-#include "mojo/public/cpp/system/macros.h"
-#include "testing/gtest/include/gtest/gtest.h"
-
-namespace mojo {
-namespace {
-
-class SetIntThread : public Thread {
- public:
-  SetIntThread(int* int_to_set, int value)
-      : int_to_set_(int_to_set),
-        value_(value) {
-  }
-  SetIntThread(const Options& options, int* int_to_set, int value)
-      : Thread(options),
-        int_to_set_(int_to_set),
-        value_(value) {
-  }
-
-  ~SetIntThread() override {}
-
-  void Run() override { *int_to_set_ = value_; }
-
- private:
-  int* const int_to_set_;
-  const int value_;
-
-  MOJO_DISALLOW_COPY_AND_ASSIGN(SetIntThread);
-};
-
-TEST(ThreadTest, CreateAndJoin) {
-  int value = 0;
-
-  // Not starting the thread should result in a no-op.
-  {
-    SetIntThread thread(&value, 1234567);
-  }
-  EXPECT_EQ(0, value);
-
-  // Start and join.
-  {
-    SetIntThread thread(&value, 12345678);
-    thread.Start();
-    thread.Join();
-    EXPECT_EQ(12345678, value);
-  }
-
-  // Ditto, with non-default (but reasonable) stack size.
-  {
-    Thread::Options options;
-    options.set_stack_size(1024 * 1024);  // 1 MB.
-    SetIntThread thread(options, &value, 12345678);
-    thread.Start();
-    thread.Join();
-    EXPECT_EQ(12345678, value);
-  }
-}
-
-// Tests of assertions for Debug builds.
-// Note: It's okay to create threads, despite gtest having to fork. (The threads
-// are in the child process.)
-#if !defined(NDEBUG)
-TEST(ThreadTest, DebugAssertionFailures) {
-  // Can only start once.
-  EXPECT_DEATH_IF_SUPPORTED({
-    int value = 0;
-    SetIntThread thread(&value, 1);
-    thread.Start();
-    thread.Start();
-  }, "");
-
-  // Must join (if you start).
-  EXPECT_DEATH_IF_SUPPORTED({
-    int value = 0;
-    SetIntThread thread(&value, 2);
-    thread.Start();
-  }, "");
-
-  // Can only join once.
-  EXPECT_DEATH_IF_SUPPORTED({
-    int value = 0;
-    SetIntThread thread(&value, 3);
-    thread.Start();
-    thread.Join();
-    thread.Join();
-  }, "");
-
-  // Stack too big (we're making certain assumptions here).
-  EXPECT_DEATH_IF_SUPPORTED({
-    int value = 0;
-    Thread::Options options;
-    options.set_stack_size(static_cast<size_t>(-1));
-    SetIntThread thread(options, &value, 4);
-    thread.Start();
-    thread.Join();
-  }, "");
-}
-#endif  // !defined(NDEBUG)
-
-}  // namespace
-}  // namespace mojo