Move base to DEPS

base/threading/platform_thread_unittest.cc

Index: base/threading/platform_thread_unittest.cc
diff --git a/base/threading/platform_thread_unittest.cc b/base/threading/platform_thread_unittest.cc
deleted file mode 100644
index 0fd9bc49591a0aab4767e778a3b60327cbd77b73..0000000000000000000000000000000000000000
--- a/base/threading/platform_thread_unittest.cc
+++ /dev/null
@@ -1,269 +0,0 @@
-// Copyright (c) 2012 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 "base/compiler_specific.h"
-#include "base/macros.h"
-#include "base/synchronization/waitable_event.h"
-#include "base/threading/platform_thread.h"
-#include "testing/gtest/include/gtest/gtest.h"
-
-#if defined(OS_POSIX)
-#include <sys/types.h>
-#include <unistd.h>
-#elif defined(OS_WIN)
-#include <windows.h>
-#endif
-
-namespace base {
-
-// Trivial tests that thread runs and doesn't crash on create and join ---------
-
-namespace {
-
-class TrivialThread : public PlatformThread::Delegate {
- public:
-  TrivialThread() : did_run_(false) {}
-
-  void ThreadMain() override { did_run_ = true; }
-
-  bool did_run() const { return did_run_; }
-
- private:
-  bool did_run_;
-
-  DISALLOW_COPY_AND_ASSIGN(TrivialThread);
-};
-
-}  // namespace
-
-TEST(PlatformThreadTest, Trivial) {
-  TrivialThread thread;
-  PlatformThreadHandle handle;
-
-  ASSERT_FALSE(thread.did_run());
-  ASSERT_TRUE(PlatformThread::Create(0, &thread, &handle));
-  PlatformThread::Join(handle);
-  ASSERT_TRUE(thread.did_run());
-}
-
-TEST(PlatformThreadTest, TrivialTimesTen) {
-  TrivialThread thread[10];
-  PlatformThreadHandle handle[arraysize(thread)];
-
-  for (size_t n = 0; n < arraysize(thread); n++)
-    ASSERT_FALSE(thread[n].did_run());
-  for (size_t n = 0; n < arraysize(thread); n++)
-    ASSERT_TRUE(PlatformThread::Create(0, &thread[n], &handle[n]));
-  for (size_t n = 0; n < arraysize(thread); n++)
-    PlatformThread::Join(handle[n]);
-  for (size_t n = 0; n < arraysize(thread); n++)
-    ASSERT_TRUE(thread[n].did_run());
-}
-
-// Tests of basic thread functions ---------------------------------------------
-
-namespace {
-
-class FunctionTestThread : public PlatformThread::Delegate {
- public:
-  FunctionTestThread()
-      : thread_id_(kInvalidThreadId),
-        termination_ready_(true, false),
-        terminate_thread_(true, false),
-        done_(false) {}
-  ~FunctionTestThread() override {
-    EXPECT_TRUE(terminate_thread_.IsSignaled())
-        << "Need to mark thread for termination and join the underlying thread "
-        << "before destroying a FunctionTestThread as it owns the "
-        << "WaitableEvent blocking the underlying thread's main.";
-  }
-
-  // Grabs |thread_id_|, runs an optional test on that thread, signals
-  // |termination_ready_|, and then waits for |terminate_thread_| to be
-  // signaled before exiting.
-  void ThreadMain() override {
-    thread_id_ = PlatformThread::CurrentId();
-    EXPECT_NE(thread_id_, kInvalidThreadId);
-
-    // Make sure that the thread ID is the same across calls.
-    EXPECT_EQ(thread_id_, PlatformThread::CurrentId());
-
-    // Run extra tests.
-    RunTest();
-
-    termination_ready_.Signal();
-    terminate_thread_.Wait();
-
-    done_ = true;
-  }
-
-  PlatformThreadId thread_id() const {
-    EXPECT_TRUE(termination_ready_.IsSignaled()) << "Thread ID still unknown";
-    return thread_id_;
-  }
-
-  bool IsRunning() const { return termination_ready_.IsSignaled() && !done_; }
-
-  // Blocks until this thread is started and ready to be terminated.
-  void WaitForTerminationReady() { termination_ready_.Wait(); }
-
-  // Marks this thread for termination (callers must then join this thread to be
-  // guaranteed of termination).
-  void MarkForTermination() { terminate_thread_.Signal(); }
-
- private:
-  // Runs an optional test on the newly created thread.
-  virtual void RunTest() {}
-
-  PlatformThreadId thread_id_;
-
-  mutable WaitableEvent termination_ready_;
-  WaitableEvent terminate_thread_;
-  bool done_;
-
-  DISALLOW_COPY_AND_ASSIGN(FunctionTestThread);
-};
-
-}  // namespace
-
-TEST(PlatformThreadTest, Function) {
-  PlatformThreadId main_thread_id = PlatformThread::CurrentId();
-
-  FunctionTestThread thread;
-  PlatformThreadHandle handle;
-
-  ASSERT_FALSE(thread.IsRunning());
-  ASSERT_TRUE(PlatformThread::Create(0, &thread, &handle));
-  thread.WaitForTerminationReady();
-  ASSERT_TRUE(thread.IsRunning());
-  EXPECT_NE(thread.thread_id(), main_thread_id);
-
-  thread.MarkForTermination();
-  PlatformThread::Join(handle);
-  ASSERT_FALSE(thread.IsRunning());
-
-  // Make sure that the thread ID is the same across calls.
-  EXPECT_EQ(main_thread_id, PlatformThread::CurrentId());
-}
-
-TEST(PlatformThreadTest, FunctionTimesTen) {
-  PlatformThreadId main_thread_id = PlatformThread::CurrentId();
-
-  FunctionTestThread thread[10];
-  PlatformThreadHandle handle[arraysize(thread)];
-
-  for (size_t n = 0; n < arraysize(thread); n++)
-    ASSERT_FALSE(thread[n].IsRunning());
-
-  for (size_t n = 0; n < arraysize(thread); n++)
-    ASSERT_TRUE(PlatformThread::Create(0, &thread[n], &handle[n]));
-  for (size_t n = 0; n < arraysize(thread); n++)
-    thread[n].WaitForTerminationReady();
-
-  for (size_t n = 0; n < arraysize(thread); n++) {
-    ASSERT_TRUE(thread[n].IsRunning());
-    EXPECT_NE(thread[n].thread_id(), main_thread_id);
-
-    // Make sure no two threads get the same ID.
-    for (size_t i = 0; i < n; ++i) {
-      EXPECT_NE(thread[i].thread_id(), thread[n].thread_id());
-    }
-  }
-
-  for (size_t n = 0; n < arraysize(thread); n++)
-    thread[n].MarkForTermination();
-  for (size_t n = 0; n < arraysize(thread); n++)
-    PlatformThread::Join(handle[n]);
-  for (size_t n = 0; n < arraysize(thread); n++)
-    ASSERT_FALSE(thread[n].IsRunning());
-
-  // Make sure that the thread ID is the same across calls.
-  EXPECT_EQ(main_thread_id, PlatformThread::CurrentId());
-}
-
-namespace {
-
-const ThreadPriority kThreadPriorityTestValues[] = {
-// The order should be higher to lower to cover as much cases as possible on
-// Linux trybots running without CAP_SYS_NICE permission.
-#if !defined(OS_ANDROID)
-    // PlatformThread::GetCurrentThreadPriority() on Android does not support
-    // REALTIME_AUDIO case. See http://crbug.com/505474.
-    ThreadPriority::REALTIME_AUDIO,
-#endif
-    ThreadPriority::DISPLAY,
-    // This redundant BACKGROUND priority is to test backgrounding from other
-    // priorities, and unbackgrounding.
-    ThreadPriority::BACKGROUND, ThreadPriority::NORMAL,
-    ThreadPriority::BACKGROUND};
-
-bool IsBumpingPriorityAllowed() {
-#if defined(OS_POSIX)
-  // Only root can raise thread priority on POSIX environment. On Linux, users
-  // who have CAP_SYS_NICE permission also can raise the thread priority, but
-  // libcap.so would be needed to check the capability.
-  return geteuid() == 0;
-#else
-  return true;
-#endif
-}
-
-class ThreadPriorityTestThread : public FunctionTestThread {
- public:
-  ThreadPriorityTestThread() = default;
-  ~ThreadPriorityTestThread() override = default;
-
- private:
-  void RunTest() override {
-    // Confirm that the current thread's priority is as expected.
-    EXPECT_EQ(ThreadPriority::NORMAL,
-              PlatformThread::GetCurrentThreadPriority());
-
-    // Toggle each supported priority on the current thread and confirm it
-    // affects it.
-    const bool bumping_priority_allowed = IsBumpingPriorityAllowed();
-    for (size_t i = 0; i < arraysize(kThreadPriorityTestValues); ++i) {
-      SCOPED_TRACE(i);
-      if (!bumping_priority_allowed &&
-          kThreadPriorityTestValues[i] >
-              PlatformThread::GetCurrentThreadPriority()) {
-        continue;
-      }
-
-      // Alter and verify the current thread's priority.
-      PlatformThread::SetCurrentThreadPriority(kThreadPriorityTestValues[i]);
-      EXPECT_EQ(kThreadPriorityTestValues[i],
-                PlatformThread::GetCurrentThreadPriority());
-    }
-  }
-
-  DISALLOW_COPY_AND_ASSIGN(ThreadPriorityTestThread);
-};
-
-}  // namespace
-
-#if defined(OS_MACOSX)
-// PlatformThread::GetCurrentThreadPriority() is not implemented on OS X.
-#define MAYBE_ThreadPriorityCurrentThread DISABLED_ThreadPriorityCurrentThread
-#else
-#define MAYBE_ThreadPriorityCurrentThread ThreadPriorityCurrentThread
-#endif
-
-// Test changing a created thread's priority (which has different semantics on
-// some platforms).
-TEST(PlatformThreadTest, MAYBE_ThreadPriorityCurrentThread) {
-  ThreadPriorityTestThread thread;
-  PlatformThreadHandle handle;
-
-  ASSERT_FALSE(thread.IsRunning());
-  ASSERT_TRUE(PlatformThread::Create(0, &thread, &handle));
-  thread.WaitForTerminationReady();
-  ASSERT_TRUE(thread.IsRunning());
-
-  thread.MarkForTermination();
-  PlatformThread::Join(handle);
-  ASSERT_FALSE(thread.IsRunning());
-}
-
-}  // namespace base