Nuke the sandbox

18 files changed, 0 insertions, 2577 deletions

diff --git a/security/sandbox/chromium/base/threading/platform_thread.h b/security/sandbox/chromium/base/threading/platform_thread.h
deleted file mode 100644
index e2b09bcb5..000000000
--- a/security/sandbox/chromium/base/threading/platform_thread.h
+++ /dev/null
@@ -1,199 +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.
-
-// WARNING: You should *NOT* be using this class directly.  PlatformThread is
-// the low-level platform-specific abstraction to the OS's threading interface.
-// You should instead be using a message-loop driven Thread, see thread.h.
-
-#ifndef BASE_THREADING_PLATFORM_THREAD_H_
-#define BASE_THREADING_PLATFORM_THREAD_H_
-
-#include <stddef.h>
-
-#include "base/base_export.h"
-#include "base/macros.h"
-#include "base/time/time.h"
-#include "build/build_config.h"
-
-#if defined(OS_WIN)
-#include <windows.h>
-#elif defined(OS_POSIX)
-#include <pthread.h>
-#include <unistd.h>
-#endif
-
-namespace base {
-
-// Used for logging. Always an integer value.
-#if defined(OS_WIN)
-typedef DWORD PlatformThreadId;
-#elif defined(OS_POSIX)
-typedef pid_t PlatformThreadId;
-#endif
-
-// Used for thread checking and debugging.
-// Meant to be as fast as possible.
-// These are produced by PlatformThread::CurrentRef(), and used to later
-// check if we are on the same thread or not by using ==. These are safe
-// to copy between threads, but can't be copied to another process as they
-// have no meaning there. Also, the internal identifier can be re-used
-// after a thread dies, so a PlatformThreadRef cannot be reliably used
-// to distinguish a new thread from an old, dead thread.
-class PlatformThreadRef {
- public:
-#if defined(OS_WIN)
-  typedef DWORD RefType;
-#elif defined(OS_POSIX)
-  typedef pthread_t RefType;
-#endif
-  PlatformThreadRef()
-      : id_(0) {
-  }
-
-  explicit PlatformThreadRef(RefType id)
-      : id_(id) {
-  }
-
-  bool operator==(PlatformThreadRef other) const {
-    return id_ == other.id_;
-  }
-
-  bool is_null() const {
-    return id_ == 0;
-  }
- private:
-  RefType id_;
-};
-
-// Used to operate on threads.
-class PlatformThreadHandle {
- public:
-#if defined(OS_WIN)
-  typedef void* Handle;
-#elif defined(OS_POSIX)
-  typedef pthread_t Handle;
-#endif
-
-  PlatformThreadHandle() : handle_(0) {}
-
-  explicit PlatformThreadHandle(Handle handle) : handle_(handle) {}
-
-  bool is_equal(const PlatformThreadHandle& other) const {
-    return handle_ == other.handle_;
-  }
-
-  bool is_null() const {
-    return !handle_;
-  }
-
-  Handle platform_handle() const {
-    return handle_;
-  }
-
- private:
-  Handle handle_;
-};
-
-const PlatformThreadId kInvalidThreadId(0);
-
-// Valid values for priority of Thread::Options and SimpleThread::Options, and
-// SetCurrentThreadPriority(), listed in increasing order of importance.
-enum class ThreadPriority {
-  // Suitable for threads that shouldn't disrupt high priority work.
-  BACKGROUND,
-  // Default priority level.
-  NORMAL,
-  // Suitable for threads which generate data for the display (at ~60Hz).
-  DISPLAY,
-  // Suitable for low-latency, glitch-resistant audio.
-  REALTIME_AUDIO,
-};
-
-// A namespace for low-level thread functions.
-class BASE_EXPORT PlatformThread {
- public:
-  // Implement this interface to run code on a background thread.  Your
-  // ThreadMain method will be called on the newly created thread.
-  class BASE_EXPORT Delegate {
-   public:
-    virtual void ThreadMain() = 0;
-
-   protected:
-    virtual ~Delegate() {}
-  };
-
-  // Gets the current thread id, which may be useful for logging purposes.
-  static PlatformThreadId CurrentId();
-
-  // Gets the current thread reference, which can be used to check if
-  // we're on the right thread quickly.
-  static PlatformThreadRef CurrentRef();
-
-  // Get the handle representing the current thread. On Windows, this is a
-  // pseudo handle constant which will always represent the thread using it and
-  // hence should not be shared with other threads nor be used to differentiate
-  // the current thread from another.
-  static PlatformThreadHandle CurrentHandle();
-
-  // Yield the current thread so another thread can be scheduled.
-  static void YieldCurrentThread();
-
-  // Sleeps for the specified duration.
-  static void Sleep(base::TimeDelta duration);
-
-  // Sets the thread name visible to debuggers/tools. This has no effect
-  // otherwise.
-  static void SetName(const std::string& name);
-
-  // Gets the thread name, if previously set by SetName.
-  static const char* GetName();
-
-  // Creates a new thread.  The |stack_size| parameter can be 0 to indicate
-  // that the default stack size should be used.  Upon success,
-  // |*thread_handle| will be assigned a handle to the newly created thread,
-  // and |delegate|'s ThreadMain method will be executed on the newly created
-  // thread.
-  // NOTE: When you are done with the thread handle, you must call Join to
-  // release system resources associated with the thread.  You must ensure that
-  // the Delegate object outlives the thread.
-  static bool Create(size_t stack_size,
-                     Delegate* delegate,
-                     PlatformThreadHandle* thread_handle) {
-    return CreateWithPriority(stack_size, delegate, thread_handle,
-                              ThreadPriority::NORMAL);
-  }
-
-  // CreateWithPriority() does the same thing as Create() except the priority of
-  // the thread is set based on |priority|.
-  static bool CreateWithPriority(size_t stack_size, Delegate* delegate,
-                                 PlatformThreadHandle* thread_handle,
-                                 ThreadPriority priority);
-
-  // CreateNonJoinable() does the same thing as Create() except the thread
-  // cannot be Join()'d.  Therefore, it also does not output a
-  // PlatformThreadHandle.
-  static bool CreateNonJoinable(size_t stack_size, Delegate* delegate);
-
-  // Joins with a thread created via the Create function.  This function blocks
-  // the caller until the designated thread exits.  This will invalidate
-  // |thread_handle|.
-  static void Join(PlatformThreadHandle thread_handle);
-
-  // Toggles the current thread's priority at runtime. A thread may not be able
-  // to raise its priority back up after lowering it if the process does not
-  // have a proper permission, e.g. CAP_SYS_NICE on Linux.
-  // Since changing other threads' priority is not permitted in favor of
-  // security, this interface is restricted to change only the current thread
-  // priority (https://crbug.com/399473).
-  static void SetCurrentThreadPriority(ThreadPriority priority);
-
-  static ThreadPriority GetCurrentThreadPriority();
-
- private:
-  DISALLOW_IMPLICIT_CONSTRUCTORS(PlatformThread);
-};
-
-}  // namespace base
-
-#endif  // BASE_THREADING_PLATFORM_THREAD_H_
diff --git a/security/sandbox/chromium/base/threading/platform_thread_internal_posix.cc b/security/sandbox/chromium/base/threading/platform_thread_internal_posix.cc
deleted file mode 100644
index 9af02044f..000000000
--- a/security/sandbox/chromium/base/threading/platform_thread_internal_posix.cc
+++ /dev/null
@@ -1,35 +0,0 @@
-// 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 "base/threading/platform_thread_internal_posix.h"
-
-#include "base/logging.h"
-
-namespace base {
-
-namespace internal {
-
-int ThreadPriorityToNiceValue(ThreadPriority priority) {
-  for (const ThreadPriorityToNiceValuePair& pair :
-       kThreadPriorityToNiceValueMap) {
-    if (pair.priority == priority)
-      return pair.nice_value;
-  }
-  NOTREACHED() << "Unknown ThreadPriority";
-  return 0;
-}
-
-ThreadPriority NiceValueToThreadPriority(int nice_value) {
-  for (const ThreadPriorityToNiceValuePair& pair :
-       kThreadPriorityToNiceValueMap) {
-    if (pair.nice_value == nice_value)
-      return pair.priority;
-  }
-  NOTREACHED() << "Unknown nice value";
-  return ThreadPriority::NORMAL;
-}
-
-}  // namespace internal
-
-}  // namespace base
diff --git a/security/sandbox/chromium/base/threading/platform_thread_internal_posix.h b/security/sandbox/chromium/base/threading/platform_thread_internal_posix.h
deleted file mode 100644
index 05a8d1e26..000000000
--- a/security/sandbox/chromium/base/threading/platform_thread_internal_posix.h
+++ /dev/null
@@ -1,43 +0,0 @@
-// 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.
-
-#ifndef BASE_THREADING_PLATFORM_THREAD_INTERNAL_POSIX_H_
-#define BASE_THREADING_PLATFORM_THREAD_INTERNAL_POSIX_H_
-
-#include "base/threading/platform_thread.h"
-
-namespace base {
-
-namespace internal {
-
-struct ThreadPriorityToNiceValuePair {
-  ThreadPriority priority;
-  int nice_value;
-};
-extern const ThreadPriorityToNiceValuePair kThreadPriorityToNiceValueMap[4];
-
-// Returns the nice value matching |priority| based on the platform-specific
-// implementation of kThreadPriorityToNiceValueMap.
-int ThreadPriorityToNiceValue(ThreadPriority priority);
-
-// Returns the ThreadPrioirty matching |nice_value| based on the platform-
-// specific implementation of kThreadPriorityToNiceValueMap.
-ThreadPriority NiceValueToThreadPriority(int nice_value);
-
-// Allows platform specific tweaks to the generic POSIX solution for
-// SetCurrentThreadPriority. Returns true if the platform-specific
-// implementation handled this |priority| change, false if the generic
-// implementation should instead proceed.
-bool SetCurrentThreadPriorityForPlatform(ThreadPriority priority);
-
-// Returns true if there is a platform-specific ThreadPriority set on the
-// current thread (and returns the actual ThreadPriority via |priority|).
-// Returns false otherwise, leaving |priority| untouched.
-bool GetCurrentThreadPriorityForPlatform(ThreadPriority* priority);
-
-}  // namespace internal
-
-}  // namespace base
-
-#endif  // BASE_THREADING_PLATFORM_THREAD_INTERNAL_POSIX_H_
diff --git a/security/sandbox/chromium/base/threading/platform_thread_linux.cc b/security/sandbox/chromium/base/threading/platform_thread_linux.cc
deleted file mode 100644
index 4057ede94..000000000
--- a/security/sandbox/chromium/base/threading/platform_thread_linux.cc
+++ /dev/null
@@ -1,120 +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/threading/platform_thread.h"
-
-#include <errno.h>
-#include <sched.h>
-#include <stddef.h>
-
-#include "base/lazy_instance.h"
-#include "base/logging.h"
-#include "base/threading/platform_thread_internal_posix.h"
-#include "base/threading/thread_id_name_manager.h"
-#include "base/tracked_objects.h"
-#include "build/build_config.h"
-
-#if !defined(OS_NACL)
-#include <pthread.h>
-#include <sys/prctl.h>
-#include <sys/types.h>
-#include <unistd.h>
-#endif
-
-namespace base {
-
-namespace internal {
-
-namespace {
-#if !defined(OS_NACL)
-const struct sched_param kRealTimePrio = {8};
-const struct sched_param kResetPrio = {0};
-#endif
-}  // namespace
-
-const ThreadPriorityToNiceValuePair kThreadPriorityToNiceValueMap[4] = {
-    {ThreadPriority::BACKGROUND, 10},
-    {ThreadPriority::NORMAL, 0},
-    {ThreadPriority::DISPLAY, -6},
-    {ThreadPriority::REALTIME_AUDIO, -10},
-};
-
-bool SetCurrentThreadPriorityForPlatform(ThreadPriority priority) {
-#if !defined(OS_NACL)
-  ThreadPriority current_priority;
-  if (priority != ThreadPriority::REALTIME_AUDIO &&
-      GetCurrentThreadPriorityForPlatform(&current_priority) &&
-      current_priority == ThreadPriority::REALTIME_AUDIO) {
-    // If the pthread's round-robin scheduler is already enabled, and the new
-    // priority will use setpriority() instead, the pthread scheduler should be
-    // reset to use SCHED_OTHER so that setpriority() just works.
-    pthread_setschedparam(pthread_self(), SCHED_OTHER, &kResetPrio);
-    return false;
-  }
-  return priority == ThreadPriority::REALTIME_AUDIO  &&
-         pthread_setschedparam(pthread_self(), SCHED_RR, &kRealTimePrio) == 0;
-#else
-  return false;
-#endif
-}
-
-bool GetCurrentThreadPriorityForPlatform(ThreadPriority* priority) {
-#if !defined(OS_NACL)
-  int maybe_sched_rr = 0;
-  struct sched_param maybe_realtime_prio = {0};
-  if (pthread_getschedparam(pthread_self(), &maybe_sched_rr,
-                            &maybe_realtime_prio) == 0 &&
-      maybe_sched_rr == SCHED_RR &&
-      maybe_realtime_prio.sched_priority == kRealTimePrio.sched_priority) {
-    *priority = ThreadPriority::REALTIME_AUDIO;
-    return true;
-  }
-#endif
-  return false;
-}
-
-}  // namespace internal
-
-// static
-void PlatformThread::SetName(const std::string& name) {
-  ThreadIdNameManager::GetInstance()->SetName(CurrentId(), name);
-  tracked_objects::ThreadData::InitializeThreadContext(name);
-
-#if !defined(OS_NACL)
-  // On linux we can get the thread names to show up in the debugger by setting
-  // the process name for the LWP.  We don't want to do this for the main
-  // thread because that would rename the process, causing tools like killall
-  // to stop working.
-  if (PlatformThread::CurrentId() == getpid())
-    return;
-
-  // http://0pointer.de/blog/projects/name-your-threads.html
-  // Set the name for the LWP (which gets truncated to 15 characters).
-  // Note that glibc also has a 'pthread_setname_np' api, but it may not be
-  // available everywhere and it's only benefit over using prctl directly is
-  // that it can set the name of threads other than the current thread.
-  int err = prctl(PR_SET_NAME, name.c_str());
-  // We expect EPERM failures in sandboxed processes, just ignore those.
-  if (err < 0 && errno != EPERM)
-    DPLOG(ERROR) << "prctl(PR_SET_NAME)";
-#endif  //  !defined(OS_NACL)
-}
-
-void InitThreading() {}
-
-void InitOnThread() {}
-
-void TerminateOnThread() {}
-
-size_t GetDefaultThreadStackSize(const pthread_attr_t& attributes) {
-#if !defined(THREAD_SANITIZER)
-  return 0;
-#else
-  // ThreadSanitizer bloats the stack heavily. Evidence has been that the
-  // default stack size isn't enough for some browser tests.
-  return 2 * (1 << 23);  // 2 times 8192K (the default stack size on Linux).
-#endif
-}
-
-}  // namespace base
diff --git a/security/sandbox/chromium/base/threading/platform_thread_posix.cc b/security/sandbox/chromium/base/threading/platform_thread_posix.cc
deleted file mode 100644
index 39a007316..000000000
--- a/security/sandbox/chromium/base/threading/platform_thread_posix.cc
+++ /dev/null
@@ -1,263 +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/threading/platform_thread.h"
-
-#include <errno.h>
-#include <pthread.h>
-#include <sched.h>
-#include <stddef.h>
-#include <stdint.h>
-#include <sys/resource.h>
-#include <sys/time.h>
-
-#include "base/lazy_instance.h"
-#include "base/logging.h"
-#include "base/memory/scoped_ptr.h"
-#include "base/threading/platform_thread_internal_posix.h"
-#include "base/threading/thread_id_name_manager.h"
-#include "base/threading/thread_restrictions.h"
-#include "build/build_config.h"
-
-#if defined(OS_LINUX)
-#include <sys/syscall.h>
-#elif defined(OS_ANDROID)
-#include <sys/types.h>
-#endif
-
-namespace base {
-
-void InitThreading();
-void InitOnThread();
-void TerminateOnThread();
-size_t GetDefaultThreadStackSize(const pthread_attr_t& attributes);
-
-namespace {
-
-struct ThreadParams {
-  ThreadParams()
-      : delegate(NULL), joinable(false), priority(ThreadPriority::NORMAL) {}
-
-  PlatformThread::Delegate* delegate;
-  bool joinable;
-  ThreadPriority priority;
-};
-
-void* ThreadFunc(void* params) {
-  base::InitOnThread();
-
-  PlatformThread::Delegate* delegate = nullptr;
-
-  {
-    scoped_ptr<ThreadParams> thread_params(static_cast<ThreadParams*>(params));
-
-    delegate = thread_params->delegate;
-    if (!thread_params->joinable)
-      base::ThreadRestrictions::SetSingletonAllowed(false);
-
-    if (thread_params->priority != ThreadPriority::NORMAL)
-      PlatformThread::SetCurrentThreadPriority(thread_params->priority);
-  }
-
-  ThreadIdNameManager::GetInstance()->RegisterThread(
-      PlatformThread::CurrentHandle().platform_handle(),
-      PlatformThread::CurrentId());
-
-  delegate->ThreadMain();
-
-  ThreadIdNameManager::GetInstance()->RemoveName(
-      PlatformThread::CurrentHandle().platform_handle(),
-      PlatformThread::CurrentId());
-
-  base::TerminateOnThread();
-  return NULL;
-}
-
-bool CreateThread(size_t stack_size,
-                  bool joinable,
-                  PlatformThread::Delegate* delegate,
-                  PlatformThreadHandle* thread_handle,
-                  ThreadPriority priority) {
-  DCHECK(thread_handle);
-  base::InitThreading();
-
-  pthread_attr_t attributes;
-  pthread_attr_init(&attributes);
-
-  // Pthreads are joinable by default, so only specify the detached
-  // attribute if the thread should be non-joinable.
-  if (!joinable)
-    pthread_attr_setdetachstate(&attributes, PTHREAD_CREATE_DETACHED);
-
-  // Get a better default if available.
-  if (stack_size == 0)
-    stack_size = base::GetDefaultThreadStackSize(attributes);
-
-  if (stack_size > 0)
-    pthread_attr_setstacksize(&attributes, stack_size);
-
-  scoped_ptr<ThreadParams> params(new ThreadParams);
-  params->delegate = delegate;
-  params->joinable = joinable;
-  params->priority = priority;
-
-  pthread_t handle;
-  int err = pthread_create(&handle, &attributes, ThreadFunc, params.get());
-  bool success = !err;
-  if (success) {
-    // ThreadParams should be deleted on the created thread after used.
-    ignore_result(params.release());
-  } else {
-    // Value of |handle| is undefined if pthread_create fails.
-    handle = 0;
-    errno = err;
-    PLOG(ERROR) << "pthread_create";
-  }
-  *thread_handle = PlatformThreadHandle(handle);
-
-  pthread_attr_destroy(&attributes);
-
-  return success;
-}
-
-}  // namespace
-
-// static
-PlatformThreadId PlatformThread::CurrentId() {
-  // Pthreads doesn't have the concept of a thread ID, so we have to reach down
-  // into the kernel.
-#if defined(OS_MACOSX)
-  return pthread_mach_thread_np(pthread_self());
-#elif defined(OS_LINUX)
-  return syscall(__NR_gettid);
-#elif defined(OS_ANDROID)
-  return gettid();
-#elif defined(OS_SOLARIS) || defined(OS_QNX)
-  return pthread_self();
-#elif defined(OS_NACL) && defined(__GLIBC__)
-  return pthread_self();
-#elif defined(OS_NACL) && !defined(__GLIBC__)
-  // Pointers are 32-bits in NaCl.
-  return reinterpret_cast<int32_t>(pthread_self());
-#elif defined(OS_POSIX)
-  return reinterpret_cast<int64_t>(pthread_self());
-#endif
-}
-
-// static
-PlatformThreadRef PlatformThread::CurrentRef() {
-  return PlatformThreadRef(pthread_self());
-}
-
-// static
-PlatformThreadHandle PlatformThread::CurrentHandle() {
-  return PlatformThreadHandle(pthread_self());
-}
-
-// static
-void PlatformThread::YieldCurrentThread() {
-  sched_yield();
-}
-
-// static
-void PlatformThread::Sleep(TimeDelta duration) {
-  struct timespec sleep_time, remaining;
-
-  // Break the duration into seconds and nanoseconds.
-  // NOTE: TimeDelta's microseconds are int64s while timespec's
-  // nanoseconds are longs, so this unpacking must prevent overflow.
-  sleep_time.tv_sec = duration.InSeconds();
-  duration -= TimeDelta::FromSeconds(sleep_time.tv_sec);
-  sleep_time.tv_nsec = duration.InMicroseconds() * 1000;  // nanoseconds
-
-  while (nanosleep(&sleep_time, &remaining) == -1 && errno == EINTR)
-    sleep_time = remaining;
-}
-
-// static
-const char* PlatformThread::GetName() {
-  return ThreadIdNameManager::GetInstance()->GetName(CurrentId());
-}
-
-// static
-bool PlatformThread::CreateWithPriority(size_t stack_size, Delegate* delegate,
-                                        PlatformThreadHandle* thread_handle,
-                                        ThreadPriority priority) {
-  return CreateThread(stack_size, true,  // joinable thread
-                      delegate, thread_handle, priority);
-}
-
-// static
-bool PlatformThread::CreateNonJoinable(size_t stack_size, Delegate* delegate) {
-  PlatformThreadHandle unused;
-
-  bool result = CreateThread(stack_size, false /* non-joinable thread */,
-                             delegate, &unused, ThreadPriority::NORMAL);
-  return result;
-}
-
-// static
-void PlatformThread::Join(PlatformThreadHandle thread_handle) {
-  // Joining another thread may block the current thread for a long time, since
-  // the thread referred to by |thread_handle| may still be running long-lived /
-  // blocking tasks.
-  base::ThreadRestrictions::AssertIOAllowed();
-  CHECK_EQ(0, pthread_join(thread_handle.platform_handle(), NULL));
-}
-
-// Mac has its own Set/GetCurrentThreadPriority() implementations.
-#if !defined(OS_MACOSX)
-
-// static
-void PlatformThread::SetCurrentThreadPriority(ThreadPriority priority) {
-#if defined(OS_NACL)
-  NOTIMPLEMENTED();
-#else
-  if (internal::SetCurrentThreadPriorityForPlatform(priority))
-    return;
-
-  // setpriority(2) should change the whole thread group's (i.e. process)
-  // priority. However, as stated in the bugs section of
-  // http://man7.org/linux/man-pages/man2/getpriority.2.html: "under the current
-  // Linux/NPTL implementation of POSIX threads, the nice value is a per-thread
-  // attribute". Also, 0 is prefered to the current thread id since it is
-  // equivalent but makes sandboxing easier (https://crbug.com/399473).
-  const int nice_setting = internal::ThreadPriorityToNiceValue(priority);
-  if (setpriority(PRIO_PROCESS, 0, nice_setting)) {
-    DVPLOG(1) << "Failed to set nice value of thread ("
-              << PlatformThread::CurrentId() << ") to " << nice_setting;
-  }
-#endif  // defined(OS_NACL)
-}
-
-// static
-ThreadPriority PlatformThread::GetCurrentThreadPriority() {
-#if defined(OS_NACL)
-  NOTIMPLEMENTED();
-  return ThreadPriority::NORMAL;
-#else
-  // Mirrors SetCurrentThreadPriority()'s implementation.
-  ThreadPriority platform_specific_priority;
-  if (internal::GetCurrentThreadPriorityForPlatform(
-          &platform_specific_priority)) {
-    return platform_specific_priority;
-  }
-
-  // Need to clear errno before calling getpriority():
-  // http://man7.org/linux/man-pages/man2/getpriority.2.html
-  errno = 0;
-  int nice_value = getpriority(PRIO_PROCESS, 0);
-  if (errno != 0) {
-    DVPLOG(1) << "Failed to get nice value of thread ("
-              << PlatformThread::CurrentId() << ")";
-    return ThreadPriority::NORMAL;
-  }
-
-  return internal::NiceValueToThreadPriority(nice_value);
-#endif  // !defined(OS_NACL)
-}
-
-#endif  // !defined(OS_MACOSX)
-
-}  // namespace base
diff --git a/security/sandbox/chromium/base/threading/platform_thread_win.cc b/security/sandbox/chromium/base/threading/platform_thread_win.cc
deleted file mode 100644
index d5bd9bed0..000000000
--- a/security/sandbox/chromium/base/threading/platform_thread_win.cc
+++ /dev/null
@@ -1,284 +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/threading/platform_thread.h"
-
-#include <stddef.h>
-
-#include "base/debug/alias.h"
-#include "base/debug/profiler.h"
-#include "base/logging.h"
-#include "base/threading/thread_id_name_manager.h"
-#include "base/threading/thread_restrictions.h"
-#include "base/tracked_objects.h"
-#include "base/win/scoped_handle.h"
-#include "base/win/windows_version.h"
-
-namespace base {
-
-namespace {
-
-// The information on how to set the thread name comes from
-// a MSDN article: http://msdn2.microsoft.com/en-us/library/xcb2z8hs.aspx
-const DWORD kVCThreadNameException = 0x406D1388;
-
-typedef struct tagTHREADNAME_INFO {
-  DWORD dwType;  // Must be 0x1000.
-  LPCSTR szName;  // Pointer to name (in user addr space).
-  DWORD dwThreadID;  // Thread ID (-1=caller thread).
-  DWORD dwFlags;  // Reserved for future use, must be zero.
-} THREADNAME_INFO;
-
-// This function has try handling, so it is separated out of its caller.
-void SetNameInternal(PlatformThreadId thread_id, const char* name) {
-  THREADNAME_INFO info;
-  info.dwType = 0x1000;
-  info.szName = name;
-  info.dwThreadID = thread_id;
-  info.dwFlags = 0;
-
-  __try {
-    RaiseException(kVCThreadNameException, 0, sizeof(info)/sizeof(DWORD),
-                   reinterpret_cast<DWORD_PTR*>(&info));
-  } __except(EXCEPTION_CONTINUE_EXECUTION) {
-  }
-}
-
-struct ThreadParams {
-  PlatformThread::Delegate* delegate;
-  bool joinable;
-  ThreadPriority priority;
-};
-
-DWORD __stdcall ThreadFunc(void* params) {
-  ThreadParams* thread_params = static_cast<ThreadParams*>(params);
-  PlatformThread::Delegate* delegate = thread_params->delegate;
-  if (!thread_params->joinable)
-    base::ThreadRestrictions::SetSingletonAllowed(false);
-
-  if (thread_params->priority != ThreadPriority::NORMAL)
-    PlatformThread::SetCurrentThreadPriority(thread_params->priority);
-
-  // Retrieve a copy of the thread handle to use as the key in the
-  // thread name mapping.
-  PlatformThreadHandle::Handle platform_handle;
-  BOOL did_dup = DuplicateHandle(GetCurrentProcess(),
-                                GetCurrentThread(),
-                                GetCurrentProcess(),
-                                &platform_handle,
-                                0,
-                                FALSE,
-                                DUPLICATE_SAME_ACCESS);
-
-  win::ScopedHandle scoped_platform_handle;
-
-  if (did_dup) {
-    scoped_platform_handle.Set(platform_handle);
-    ThreadIdNameManager::GetInstance()->RegisterThread(
-        scoped_platform_handle.Get(),
-        PlatformThread::CurrentId());
-  }
-
-  delete thread_params;
-  delegate->ThreadMain();
-
-  if (did_dup) {
-    ThreadIdNameManager::GetInstance()->RemoveName(
-        scoped_platform_handle.Get(),
-        PlatformThread::CurrentId());
-  }
-
-  return 0;
-}
-
-// CreateThreadInternal() matches PlatformThread::CreateWithPriority(), except
-// that |out_thread_handle| may be nullptr, in which case a non-joinable thread
-// is created.
-bool CreateThreadInternal(size_t stack_size,
-                          PlatformThread::Delegate* delegate,
-                          PlatformThreadHandle* out_thread_handle,
-                          ThreadPriority priority) {
-  unsigned int flags = 0;
-  if (stack_size > 0 && base::win::GetVersion() >= base::win::VERSION_XP) {
-    flags = STACK_SIZE_PARAM_IS_A_RESERVATION;
-  } else {
-    stack_size = 0;
-  }
-
-  ThreadParams* params = new ThreadParams;
-  params->delegate = delegate;
-  params->joinable = out_thread_handle != nullptr;
-  params->priority = priority;
-
-  // Using CreateThread here vs _beginthreadex makes thread creation a bit
-  // faster and doesn't require the loader lock to be available.  Our code will
-  // have to work running on CreateThread() threads anyway, since we run code
-  // on the Windows thread pool, etc.  For some background on the difference:
-  //   http://www.microsoft.com/msj/1099/win32/win321099.aspx
-  void* thread_handle =
-      ::CreateThread(nullptr, stack_size, ThreadFunc, params, flags, nullptr);
-  if (!thread_handle) {
-    delete params;
-    return false;
-  }
-
-  if (out_thread_handle)
-    *out_thread_handle = PlatformThreadHandle(thread_handle);
-  else
-    CloseHandle(thread_handle);
-  return true;
-}
-
-}  // namespace
-
-// static
-PlatformThreadId PlatformThread::CurrentId() {
-  return ::GetCurrentThreadId();
-}
-
-// static
-PlatformThreadRef PlatformThread::CurrentRef() {
-  return PlatformThreadRef(::GetCurrentThreadId());
-}
-
-// static
-PlatformThreadHandle PlatformThread::CurrentHandle() {
-  return PlatformThreadHandle(::GetCurrentThread());
-}
-
-// static
-void PlatformThread::YieldCurrentThread() {
-  ::Sleep(0);
-}
-
-// static
-void PlatformThread::Sleep(TimeDelta duration) {
-  // When measured with a high resolution clock, Sleep() sometimes returns much
-  // too early. We may need to call it repeatedly to get the desired duration.
-  TimeTicks end = TimeTicks::Now() + duration;
-  for (TimeTicks now = TimeTicks::Now(); now < end; now = TimeTicks::Now())
-    ::Sleep(static_cast<DWORD>((end - now).InMillisecondsRoundedUp()));
-}
-
-// static
-void PlatformThread::SetName(const std::string& name) {
-  ThreadIdNameManager::GetInstance()->SetName(CurrentId(), name);
-
-  // On Windows only, we don't need to tell the profiler about the "BrokerEvent"
-  // thread, as it exists only in the chrome.exe image, and never spawns or runs
-  // tasks (items which could be profiled).  This test avoids the notification,
-  // which would also (as a side effect) initialize the profiler in this unused
-  // context, including setting up thread local storage, etc.  The performance
-  // impact is not terrible, but there is no reason to do initialize it.
-  if (name != "BrokerEvent")
-    tracked_objects::ThreadData::InitializeThreadContext(name);
-
-  // The debugger needs to be around to catch the name in the exception.  If
-  // there isn't a debugger, we are just needlessly throwing an exception.
-  // If this image file is instrumented, we raise the exception anyway
-  // to provide the profiler with human-readable thread names.
-  if (!::IsDebuggerPresent() && !base::debug::IsBinaryInstrumented())
-    return;
-
-  SetNameInternal(CurrentId(), name.c_str());
-}
-
-// static
-const char* PlatformThread::GetName() {
-  return ThreadIdNameManager::GetInstance()->GetName(CurrentId());
-}
-
-// static
-bool PlatformThread::CreateWithPriority(size_t stack_size, Delegate* delegate,
-                                        PlatformThreadHandle* thread_handle,
-                                        ThreadPriority priority) {
-  DCHECK(thread_handle);
-  return CreateThreadInternal(stack_size, delegate, thread_handle, priority);
-}
-
-// static
-bool PlatformThread::CreateNonJoinable(size_t stack_size, Delegate* delegate) {
-  return CreateThreadInternal(stack_size, delegate, nullptr,
-                              ThreadPriority::NORMAL);
-}
-
-// static
-void PlatformThread::Join(PlatformThreadHandle thread_handle) {
-  DCHECK(thread_handle.platform_handle());
-  // TODO(willchan): Enable this check once I can get it to work for Windows
-  // shutdown.
-  // Joining another thread may block the current thread for a long time, since
-  // the thread referred to by |thread_handle| may still be running long-lived /
-  // blocking tasks.
-#if 0
-  base::ThreadRestrictions::AssertIOAllowed();
-#endif
-
-  // Wait for the thread to exit.  It should already have terminated but make
-  // sure this assumption is valid.
-  DWORD result = WaitForSingleObject(thread_handle.platform_handle(), INFINITE);
-  if (result != WAIT_OBJECT_0) {
-    // Debug info for bug 127931.
-    DWORD error = GetLastError();
-    debug::Alias(&error);
-    debug::Alias(&result);
-    CHECK(false);
-  }
-
-  CloseHandle(thread_handle.platform_handle());
-}
-
-// static
-void PlatformThread::SetCurrentThreadPriority(ThreadPriority priority) {
-  int desired_priority = THREAD_PRIORITY_ERROR_RETURN;
-  switch (priority) {
-    case ThreadPriority::BACKGROUND:
-      desired_priority = THREAD_PRIORITY_LOWEST;
-      break;
-    case ThreadPriority::NORMAL:
-      desired_priority = THREAD_PRIORITY_NORMAL;
-      break;
-    case ThreadPriority::DISPLAY:
-      desired_priority = THREAD_PRIORITY_ABOVE_NORMAL;
-      break;
-    case ThreadPriority::REALTIME_AUDIO:
-      desired_priority = THREAD_PRIORITY_TIME_CRITICAL;
-      break;
-    default:
-      NOTREACHED() << "Unknown priority.";
-      break;
-  }
-  DCHECK_NE(desired_priority, THREAD_PRIORITY_ERROR_RETURN);
-
-#ifndef NDEBUG
-  const BOOL success =
-#endif
-      ::SetThreadPriority(PlatformThread::CurrentHandle().platform_handle(),
-                          desired_priority);
-  DPLOG_IF(ERROR, !success) << "Failed to set thread priority to "
-                            << desired_priority;
-}
-
-// static
-ThreadPriority PlatformThread::GetCurrentThreadPriority() {
-  int priority =
-      ::GetThreadPriority(PlatformThread::CurrentHandle().platform_handle());
-  switch (priority) {
-    case THREAD_PRIORITY_LOWEST:
-      return ThreadPriority::BACKGROUND;
-    case THREAD_PRIORITY_NORMAL:
-      return ThreadPriority::NORMAL;
-    case THREAD_PRIORITY_ABOVE_NORMAL:
-      return ThreadPriority::DISPLAY;
-    case THREAD_PRIORITY_TIME_CRITICAL:
-      return ThreadPriority::REALTIME_AUDIO;
-    case THREAD_PRIORITY_ERROR_RETURN:
-      DPCHECK(false) << "GetThreadPriority error";  // Falls through.
-    default:
-      NOTREACHED() << "Unexpected priority: " << priority;
-      return ThreadPriority::NORMAL;
-  }
-}
-
-}  // namespace base
diff --git a/security/sandbox/chromium/base/threading/sequenced_worker_pool.h b/security/sandbox/chromium/base/threading/sequenced_worker_pool.h
deleted file mode 100644
index ba0e44421..000000000
--- a/security/sandbox/chromium/base/threading/sequenced_worker_pool.h
+++ /dev/null
@@ -1,384 +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.
-
-#ifndef BASE_THREADING_SEQUENCED_WORKER_POOL_H_
-#define BASE_THREADING_SEQUENCED_WORKER_POOL_H_
-
-#include <stddef.h>
-
-#include <cstddef>
-#include <string>
-
-#include "base/base_export.h"
-#include "base/callback_forward.h"
-#include "base/macros.h"
-#include "base/memory/ref_counted.h"
-#include "base/memory/scoped_ptr.h"
-#include "base/single_thread_task_runner.h"
-#include "base/task_runner.h"
-
-namespace tracked_objects {
-class Location;
-}  // namespace tracked_objects
-
-namespace base {
-
-class SingleThreadTaskRunner;
-
-template <class T> class DeleteHelper;
-
-class SequencedTaskRunner;
-
-// A worker thread pool that enforces ordering between sets of tasks. It also
-// allows you to specify what should happen to your tasks on shutdown.
-//
-// To enforce ordering, get a unique sequence token from the pool and post all
-// tasks you want to order with the token. All tasks with the same token are
-// guaranteed to execute serially, though not necessarily on the same thread.
-// This means that:
-//
-//   - No two tasks with the same token will run at the same time.
-//
-//   - Given two tasks T1 and T2 with the same token such that T2 will
-//     run after T1, then T2 will start after T1 is destroyed.
-//
-//   - If T2 will run after T1, then all memory changes in T1 and T1's
-//     destruction will be visible to T2.
-//
-// Example:
-//   SequencedWorkerPool::SequenceToken token =
-//       SequencedWorkerPool::GetSequenceToken();
-//   pool.PostSequencedWorkerTask(token, SequencedWorkerPool::SKIP_ON_SHUTDOWN,
-//                                FROM_HERE, base::Bind(...));
-//   pool.PostSequencedWorkerTask(token, SequencedWorkerPool::SKIP_ON_SHUTDOWN,
-//                                FROM_HERE, base::Bind(...));
-//
-// You can make named sequence tokens to make it easier to share a token
-// across different components.
-//
-// You can also post tasks to the pool without ordering using PostWorkerTask.
-// These will be executed in an unspecified order. The order of execution
-// between tasks with different sequence tokens is also unspecified.
-//
-// This class may be leaked on shutdown to facilitate fast shutdown. The
-// expected usage, however, is to call Shutdown(), which correctly accounts
-// for CONTINUE_ON_SHUTDOWN behavior and is required for BLOCK_SHUTDOWN
-// behavior.
-//
-// Implementation note: This does not use a base::WorkerPool since that does
-// not enforce shutdown semantics or allow us to specify how many worker
-// threads to run. For the typical use case of random background work, we don't
-// necessarily want to be super aggressive about creating threads.
-//
-// Note that SequencedWorkerPool is RefCountedThreadSafe (inherited
-// from TaskRunner).
-//
-// Test-only code should wrap this in a base::SequencedWorkerPoolOwner to avoid
-// memory leaks. See http://crbug.com/273800
-class BASE_EXPORT SequencedWorkerPool : public TaskRunner {
- public:
-  // Defines what should happen to a task posted to the worker pool on
-  // shutdown.
-  enum WorkerShutdown {
-    // Tasks posted with this mode which have not run at shutdown will be
-    // deleted rather than run, and any tasks with this mode running at
-    // shutdown will be ignored (the worker thread will not be joined).
-    //
-    // This option provides a nice way to post stuff you don't want blocking
-    // shutdown. For example, you might be doing a slow DNS lookup and if it's
-    // blocked on the OS, you may not want to stop shutdown, since the result
-    // doesn't really matter at that point.
-    //
-    // However, you need to be very careful what you do in your callback when
-    // you use this option. Since the thread will continue to run until the OS
-    // terminates the process, the app can be in the process of tearing down
-    // when you're running. This means any singletons or global objects you
-    // use may suddenly become invalid out from under you. For this reason,
-    // it's best to use this only for slow but simple operations like the DNS
-    // example.
-    CONTINUE_ON_SHUTDOWN,
-
-    // Tasks posted with this mode that have not started executing at
-    // shutdown will be deleted rather than executed. However, any tasks that
-    // have already begun executing when shutdown is called will be allowed
-    // to continue, and will block shutdown until completion.
-    //
-    // Note: Because Shutdown() may block while these tasks are executing,
-    // care must be taken to ensure that they do not block on the thread that
-    // called Shutdown(), as this may lead to deadlock.
-    SKIP_ON_SHUTDOWN,
-
-    // Tasks posted with this mode will block shutdown until they're
-    // executed. Since this can have significant performance implications,
-    // use sparingly.
-    //
-    // Generally, this should be used only for user data, for example, a task
-    // writing a preference file.
-    //
-    // If a task is posted during shutdown, it will not get run since the
-    // workers may already be stopped. In this case, the post operation will
-    // fail (return false) and the task will be deleted.
-    BLOCK_SHUTDOWN,
-  };
-
-  // Opaque identifier that defines sequencing of tasks posted to the worker
-  // pool.
-  class BASE_EXPORT SequenceToken {
-   public:
-    SequenceToken() : id_(0) {}
-    ~SequenceToken() {}
-
-    bool Equals(const SequenceToken& other) const {
-      return id_ == other.id_;
-    }
-
-    // Returns false if current thread is executing an unsequenced task.
-    bool IsValid() const {
-      return id_ != 0;
-    }
-
-    // Returns a string representation of this token. This method should only be
-    // used for debugging.
-    std::string ToString() const;
-
-   private:
-    friend class SequencedWorkerPool;
-
-    explicit SequenceToken(int id) : id_(id) {}
-
-    int id_;
-  };
-
-  // Allows tests to perform certain actions.
-  class TestingObserver {
-   public:
-    virtual ~TestingObserver() {}
-    virtual void OnHasWork() = 0;
-    virtual void WillWaitForShutdown() = 0;
-    virtual void OnDestruct() = 0;
-  };
-
-  // Gets the SequencedToken of the current thread.
-  // If current thread is not a SequencedWorkerPool worker thread or is running
-  // an unsequenced task, returns an invalid SequenceToken.
-  static SequenceToken GetSequenceTokenForCurrentThread();
-
-  // Gets a SequencedTaskRunner for the current thread. If the current thread is
-  // running an unsequenced task, a new SequenceToken will be generated and set,
-  // so that the returned SequencedTaskRunner is guaranteed to run tasks after
-  // the current task has finished running.
-  static scoped_refptr<SequencedTaskRunner>
-  GetSequencedTaskRunnerForCurrentThread();
-
-  // Returns a unique token that can be used to sequence tasks posted to
-  // PostSequencedWorkerTask(). Valid tokens are always nonzero.
-  // TODO(bauerb): Rename this to better differentiate from
-  // GetSequenceTokenForCurrentThread().
-  static SequenceToken GetSequenceToken();
-
-  // Returns the SequencedWorkerPool that owns this thread, or null if the
-  // current thread is not a SequencedWorkerPool worker thread.
-  static scoped_refptr<SequencedWorkerPool> GetWorkerPoolForCurrentThread();
-
-  // When constructing a SequencedWorkerPool, there must be a
-  // ThreadTaskRunnerHandle on the current thread unless you plan to
-  // deliberately leak it.
-
-  // Pass the maximum number of threads (they will be lazily created as needed)
-  // and a prefix for the thread name to aid in debugging.
-  SequencedWorkerPool(size_t max_threads,
-                      const std::string& thread_name_prefix);
-
-  // Like above, but with |observer| for testing.  Does not take ownership of
-  // |observer|.
-  SequencedWorkerPool(size_t max_threads,
-                      const std::string& thread_name_prefix,
-                      TestingObserver* observer);
-
-  // Returns the sequence token associated with the given name. Calling this
-  // function multiple times with the same string will always produce the
-  // same sequence token. If the name has not been used before, a new token
-  // will be created.
-  SequenceToken GetNamedSequenceToken(const std::string& name);
-
-  // Returns a SequencedTaskRunner wrapper which posts to this
-  // SequencedWorkerPool using the given sequence token. Tasks with nonzero
-  // delay are posted with SKIP_ON_SHUTDOWN behavior and tasks with zero delay
-  // are posted with BLOCK_SHUTDOWN behavior.
-  scoped_refptr<SequencedTaskRunner> GetSequencedTaskRunner(
-      SequenceToken token);
-
-  // Returns a SequencedTaskRunner wrapper which posts to this
-  // SequencedWorkerPool using the given sequence token. Tasks with nonzero
-  // delay are posted with SKIP_ON_SHUTDOWN behavior and tasks with zero delay
-  // are posted with the given shutdown behavior.
-  scoped_refptr<SequencedTaskRunner> GetSequencedTaskRunnerWithShutdownBehavior(
-      SequenceToken token,
-      WorkerShutdown shutdown_behavior);
-
-  // Returns a TaskRunner wrapper which posts to this SequencedWorkerPool using
-  // the given shutdown behavior. Tasks with nonzero delay are posted with
-  // SKIP_ON_SHUTDOWN behavior and tasks with zero delay are posted with the
-  // given shutdown behavior.
-  scoped_refptr<TaskRunner> GetTaskRunnerWithShutdownBehavior(
-      WorkerShutdown shutdown_behavior);
-
-  // Posts the given task for execution in the worker pool. Tasks posted with
-  // this function will execute in an unspecified order on a background thread.
-  // Returns true if the task was posted. If your tasks have ordering
-  // requirements, see PostSequencedWorkerTask().
-  //
-  // This class will attempt to delete tasks that aren't run
-  // (non-block-shutdown semantics) but can't guarantee that this happens. If
-  // all worker threads are busy running CONTINUE_ON_SHUTDOWN tasks, there
-  // will be no workers available to delete these tasks. And there may be
-  // tasks with the same sequence token behind those CONTINUE_ON_SHUTDOWN
-  // tasks. Deleting those tasks before the previous one has completed could
-  // cause nondeterministic crashes because the task could be keeping some
-  // objects alive which do work in their destructor, which could voilate the
-  // assumptions of the running task.
-  //
-  // The task will be guaranteed to run to completion before shutdown
-  // (BLOCK_SHUTDOWN semantics).
-  //
-  // Returns true if the task was posted successfully. This may fail during
-  // shutdown regardless of the specified ShutdownBehavior.
-  bool PostWorkerTask(const tracked_objects::Location& from_here,
-                      const Closure& task);
-
-  // Same as PostWorkerTask but allows a delay to be specified (although doing
-  // so changes the shutdown behavior). The task will be run after the given
-  // delay has elapsed.
-  //
-  // If the delay is nonzero, the task won't be guaranteed to run to completion
-  // before shutdown (SKIP_ON_SHUTDOWN semantics) to avoid shutdown hangs.
-  // If the delay is zero, this behaves exactly like PostWorkerTask, i.e. the
-  // task will be guaranteed to run to completion before shutdown
-  // (BLOCK_SHUTDOWN semantics).
-  bool PostDelayedWorkerTask(const tracked_objects::Location& from_here,
-                             const Closure& task,
-                             TimeDelta delay);
-
-  // Same as PostWorkerTask but allows specification of the shutdown behavior.
-  bool PostWorkerTaskWithShutdownBehavior(
-      const tracked_objects::Location& from_here,
-      const Closure& task,
-      WorkerShutdown shutdown_behavior);
-
-  // Like PostWorkerTask above, but provides sequencing semantics. This means
-  // that tasks posted with the same sequence token (see GetSequenceToken())
-  // are guaranteed to execute in order. This is useful in cases where you're
-  // doing operations that may depend on previous ones, like appending to a
-  // file.
-  //
-  // The task will be guaranteed to run to completion before shutdown
-  // (BLOCK_SHUTDOWN semantics).
-  //
-  // Returns true if the task was posted successfully. This may fail during
-  // shutdown regardless of the specified ShutdownBehavior.
-  bool PostSequencedWorkerTask(SequenceToken sequence_token,
-                               const tracked_objects::Location& from_here,
-                               const Closure& task);
-
-  // Like PostSequencedWorkerTask above, but allows you to specify a named
-  // token, which saves an extra call to GetNamedSequenceToken.
-  bool PostNamedSequencedWorkerTask(const std::string& token_name,
-                                    const tracked_objects::Location& from_here,
-                                    const Closure& task);
-
-  // Same as PostSequencedWorkerTask but allows a delay to be specified
-  // (although doing so changes the shutdown behavior). The task will be run
-  // after the given delay has elapsed.
-  //
-  // If the delay is nonzero, the task won't be guaranteed to run to completion
-  // before shutdown (SKIP_ON_SHUTDOWN semantics) to avoid shutdown hangs.
-  // If the delay is zero, this behaves exactly like PostSequencedWorkerTask,
-  // i.e. the task will be guaranteed to run to completion before shutdown
-  // (BLOCK_SHUTDOWN semantics).
-  bool PostDelayedSequencedWorkerTask(
-      SequenceToken sequence_token,
-      const tracked_objects::Location& from_here,
-      const Closure& task,
-      TimeDelta delay);
-
-  // Same as PostSequencedWorkerTask but allows specification of the shutdown
-  // behavior.
-  bool PostSequencedWorkerTaskWithShutdownBehavior(
-      SequenceToken sequence_token,
-      const tracked_objects::Location& from_here,
-      const Closure& task,
-      WorkerShutdown shutdown_behavior);
-
-  // TaskRunner implementation. Forwards to PostDelayedWorkerTask().
-  bool PostDelayedTask(const tracked_objects::Location& from_here,
-                       const Closure& task,
-                       TimeDelta delay) override;
-  bool RunsTasksOnCurrentThread() const override;
-
-  // Returns true if the current thread is processing a task with the given
-  // sequence_token.
-  bool IsRunningSequenceOnCurrentThread(SequenceToken sequence_token) const;
-
-  // Returns true if any thread is currently processing a task with the given
-  // sequence token. Should only be called with a valid sequence token.
-  bool IsRunningSequence(SequenceToken sequence_token) const;
-
-  // Blocks until all pending tasks are complete. This should only be called in
-  // unit tests when you want to validate something that should have happened.
-  // This will not flush delayed tasks; delayed tasks get deleted.
-  //
-  // Note that calling this will not prevent other threads from posting work to
-  // the queue while the calling thread is waiting on Flush(). In this case,
-  // Flush will return only when there's no more work in the queue. Normally,
-  // this doesn't come up since in a test, all the work is being posted from
-  // the main thread.
-  void FlushForTesting();
-
-  // Spuriously signal that there is work to be done.
-  void SignalHasWorkForTesting();
-
-  // Implements the worker pool shutdown. This should be called during app
-  // shutdown, and will discard/join with appropriate tasks before returning.
-  // After this call, subsequent calls to post tasks will fail.
-  //
-  // Must be called from the same thread this object was constructed on.
-  void Shutdown() { Shutdown(0); }
-
-  // A variant that allows an arbitrary number of new blocking tasks to be
-  // posted during shutdown. The tasks cannot be posted within the execution
-  // context of tasks whose shutdown behavior is not BLOCKING_SHUTDOWN. Once
-  // the limit is reached, subsequent calls to post task fail in all cases.
-  // Must be called from the same thread this object was constructed on.
-  void Shutdown(int max_new_blocking_tasks_after_shutdown);
-
-  // Check if Shutdown was called for given threading pool. This method is used
-  // for aborting time consuming operation to avoid blocking shutdown.
-  //
-  // Can be called from any thread.
-  bool IsShutdownInProgress();
-
- protected:
-  ~SequencedWorkerPool() override;
-
-  void OnDestruct() const override;
-
- private:
-  friend class RefCountedThreadSafe<SequencedWorkerPool>;
-  friend class DeleteHelper<SequencedWorkerPool>;
-
-  class Inner;
-  class Worker;
-
-  const scoped_refptr<SingleThreadTaskRunner> constructor_task_runner_;
-
-  // Avoid pulling in too many headers by putting (almost) everything
-  // into |inner_|.
-  const scoped_ptr<Inner> inner_;
-
-  DISALLOW_COPY_AND_ASSIGN(SequencedWorkerPool);
-};
-
-}  // namespace base
-
-#endif  // BASE_THREADING_SEQUENCED_WORKER_POOL_H_
diff --git a/security/sandbox/chromium/base/threading/thread_checker_impl.h b/security/sandbox/chromium/base/threading/thread_checker_impl.h
deleted file mode 100644
index c92e143db..000000000
--- a/security/sandbox/chromium/base/threading/thread_checker_impl.h
+++ /dev/null
@@ -1,44 +0,0 @@
-// Copyright (c) 2011 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.
-
-#ifndef BASE_THREADING_THREAD_CHECKER_IMPL_H_
-#define BASE_THREADING_THREAD_CHECKER_IMPL_H_
-
-#include "base/base_export.h"
-#include "base/compiler_specific.h"
-#include "base/synchronization/lock.h"
-#include "base/threading/platform_thread.h"
-
-namespace base {
-
-// Real implementation of ThreadChecker, for use in debug mode, or
-// for temporary use in release mode (e.g. to CHECK on a threading issue
-// seen only in the wild).
-//
-// Note: You should almost always use the ThreadChecker class to get the
-// right version for your build configuration.
-class BASE_EXPORT ThreadCheckerImpl {
- public:
-  ThreadCheckerImpl();
-  ~ThreadCheckerImpl();
-
-  bool CalledOnValidThread() const WARN_UNUSED_RESULT;
-
-  // Changes the thread that is checked for in CalledOnValidThread.  This may
-  // be useful when an object may be created on one thread and then used
-  // exclusively on another thread.
-  void DetachFromThread();
-
- private:
-  void EnsureThreadIdAssigned() const;
-
-  mutable base::Lock lock_;
-  // This is mutable so that CalledOnValidThread can set it.
-  // It's guarded by |lock_|.
-  mutable PlatformThreadRef valid_thread_id_;
-};
-
-}  // namespace base
-
-#endif  // BASE_THREADING_THREAD_CHECKER_IMPL_H_
diff --git a/security/sandbox/chromium/base/threading/thread_collision_warner.cc b/security/sandbox/chromium/base/threading/thread_collision_warner.cc
deleted file mode 100644
index 547e11ca6..000000000
--- a/security/sandbox/chromium/base/threading/thread_collision_warner.cc
+++ /dev/null
@@ -1,64 +0,0 @@
-// Copyright (c) 2010 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/threading/thread_collision_warner.h"
-
-#include "base/logging.h"
-#include "base/threading/platform_thread.h"
-
-namespace base {
-
-void DCheckAsserter::warn() {
-  NOTREACHED() << "Thread Collision";
-}
-
-static subtle::Atomic32 CurrentThread() {
-  const PlatformThreadId current_thread_id = PlatformThread::CurrentId();
-  // We need to get the thread id into an atomic data type. This might be a
-  // truncating conversion, but any loss-of-information just increases the
-  // chance of a fault negative, not a false positive.
-  const subtle::Atomic32 atomic_thread_id =
-      static_cast<subtle::Atomic32>(current_thread_id);
-
-  return atomic_thread_id;
-}
-
-void ThreadCollisionWarner::EnterSelf() {
-  // If the active thread is 0 then I'll write the current thread ID
-  // if two or more threads arrive here only one will succeed to
-  // write on valid_thread_id_ the current thread ID.
-  subtle::Atomic32 current_thread_id = CurrentThread();
-
-  int previous_value = subtle::NoBarrier_CompareAndSwap(&valid_thread_id_,
-                                                        0,
-                                                        current_thread_id);
-  if (previous_value != 0 && previous_value != current_thread_id) {
-    // gotcha! a thread is trying to use the same class and that is
-    // not current thread.
-    asserter_->warn();
-  }
-
-  subtle::NoBarrier_AtomicIncrement(&counter_, 1);
-}
-
-void ThreadCollisionWarner::Enter() {
-  subtle::Atomic32 current_thread_id = CurrentThread();
-
-  if (subtle::NoBarrier_CompareAndSwap(&valid_thread_id_,
-                                       0,
-                                       current_thread_id) != 0) {
-    // gotcha! another thread is trying to use the same class.
-    asserter_->warn();
-  }
-
-  subtle::NoBarrier_AtomicIncrement(&counter_, 1);
-}
-
-void ThreadCollisionWarner::Leave() {
-  if (subtle::Barrier_AtomicIncrement(&counter_, -1) == 0) {
-    subtle::NoBarrier_Store(&valid_thread_id_, 0);
-  }
-}
-
-}  // namespace base
diff --git a/security/sandbox/chromium/base/threading/thread_collision_warner.h b/security/sandbox/chromium/base/threading/thread_collision_warner.h
deleted file mode 100644
index 4699a910d..000000000
--- a/security/sandbox/chromium/base/threading/thread_collision_warner.h
+++ /dev/null
@@ -1,245 +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.
-
-#ifndef BASE_THREADING_THREAD_COLLISION_WARNER_H_
-#define BASE_THREADING_THREAD_COLLISION_WARNER_H_
-
-#include <memory>
-
-#include "base/atomicops.h"
-#include "base/base_export.h"
-#include "base/compiler_specific.h"
-#include "base/macros.h"
-
-// A helper class alongside macros to be used to verify assumptions about thread
-// safety of a class.
-//
-// Example: Queue implementation non thread-safe but still usable if clients
-//          are synchronized somehow.
-//
-//          In this case the macro DFAKE_SCOPED_LOCK has to be
-//          used, it checks that if a thread is inside the push/pop then
-//          noone else is still inside the pop/push
-//
-// class NonThreadSafeQueue {
-//  public:
-//   ...
-//   void push(int) { DFAKE_SCOPED_LOCK(push_pop_); ... }
-//   int pop() { DFAKE_SCOPED_LOCK(push_pop_); ... }
-//   ...
-//  private:
-//   DFAKE_MUTEX(push_pop_);
-// };
-//
-//
-// Example: Queue implementation non thread-safe but still usable if clients
-//          are synchronized somehow, it calls a method to "protect" from
-//          a "protected" method
-//
-//          In this case the macro DFAKE_SCOPED_RECURSIVE_LOCK
-//          has to be used, it checks that if a thread is inside the push/pop
-//          then noone else is still inside the pop/push
-//
-// class NonThreadSafeQueue {
-//  public:
-//   void push(int) {
-//     DFAKE_SCOPED_LOCK(push_pop_);
-//     ...
-//   }
-//   int pop() {
-//     DFAKE_SCOPED_RECURSIVE_LOCK(push_pop_);
-//     bar();
-//     ...
-//   }
-//   void bar() { DFAKE_SCOPED_RECURSIVE_LOCK(push_pop_); ... }
-//   ...
-//  private:
-//   DFAKE_MUTEX(push_pop_);
-// };
-//
-//
-// Example: Queue implementation not usable even if clients are synchronized,
-//          so only one thread in the class life cycle can use the two members
-//          push/pop.
-//
-//          In this case the macro DFAKE_SCOPED_LOCK_THREAD_LOCKED pins the
-//          specified
-//          critical section the first time a thread enters push or pop, from
-//          that time on only that thread is allowed to execute push or pop.
-//
-// class NonThreadSafeQueue {
-//  public:
-//   ...
-//   void push(int) { DFAKE_SCOPED_LOCK_THREAD_LOCKED(push_pop_); ... }
-//   int pop() { DFAKE_SCOPED_LOCK_THREAD_LOCKED(push_pop_); ... }
-//   ...
-//  private:
-//   DFAKE_MUTEX(push_pop_);
-// };
-//
-//
-// Example: Class that has to be contructed/destroyed on same thread, it has
-//          a "shareable" method (with external synchronization) and a not
-//          shareable method (even with external synchronization).
-//
-//          In this case 3 Critical sections have to be defined
-//
-// class ExoticClass {
-//  public:
-//   ExoticClass() { DFAKE_SCOPED_LOCK_THREAD_LOCKED(ctor_dtor_); ... }
-//   ~ExoticClass() { DFAKE_SCOPED_LOCK_THREAD_LOCKED(ctor_dtor_); ... }
-//
-//   void Shareable() { DFAKE_SCOPED_LOCK(shareable_section_); ... }
-//   void NotShareable() { DFAKE_SCOPED_LOCK_THREAD_LOCKED(ctor_dtor_); ... }
-//   ...
-//  private:
-//   DFAKE_MUTEX(ctor_dtor_);
-//   DFAKE_MUTEX(shareable_section_);
-// };
-
-
-#if !defined(NDEBUG)
-
-// Defines a class member that acts like a mutex. It is used only as a
-// verification tool.
-#define DFAKE_MUTEX(obj) \
-     mutable base::ThreadCollisionWarner obj
-// Asserts the call is never called simultaneously in two threads. Used at
-// member function scope.
-#define DFAKE_SCOPED_LOCK(obj) \
-     base::ThreadCollisionWarner::ScopedCheck s_check_##obj(&obj)
-// Asserts the call is never called simultaneously in two threads. Used at
-// member function scope. Same as DFAKE_SCOPED_LOCK but allows recursive locks.
-#define DFAKE_SCOPED_RECURSIVE_LOCK(obj) \
-     base::ThreadCollisionWarner::ScopedRecursiveCheck sr_check_##obj(&obj)
-// Asserts the code is always executed in the same thread.
-#define DFAKE_SCOPED_LOCK_THREAD_LOCKED(obj) \
-     base::ThreadCollisionWarner::Check check_##obj(&obj)
-
-#else
-
-#define DFAKE_MUTEX(obj) typedef void InternalFakeMutexType##obj
-#define DFAKE_SCOPED_LOCK(obj) ((void)0)
-#define DFAKE_SCOPED_RECURSIVE_LOCK(obj) ((void)0)
-#define DFAKE_SCOPED_LOCK_THREAD_LOCKED(obj) ((void)0)
-
-#endif
-
-namespace base {
-
-// The class ThreadCollisionWarner uses an Asserter to notify the collision
-// AsserterBase is the interfaces and DCheckAsserter is the default asserter
-// used. During the unit tests is used another class that doesn't "DCHECK"
-// in case of collision (check thread_collision_warner_unittests.cc)
-struct BASE_EXPORT AsserterBase {
-  virtual ~AsserterBase() {}
-  virtual void warn() = 0;
-};
-
-struct BASE_EXPORT DCheckAsserter : public AsserterBase {
-  ~DCheckAsserter() override {}
-  void warn() override;
-};
-
-class BASE_EXPORT ThreadCollisionWarner {
- public:
-  // The parameter asserter is there only for test purpose
-  explicit ThreadCollisionWarner(AsserterBase* asserter = new DCheckAsserter())
-      : valid_thread_id_(0),
-        counter_(0),
-        asserter_(asserter) {}
-
-  ~ThreadCollisionWarner() {
-    delete asserter_;
-  }
-
-  // This class is meant to be used through the macro
-  // DFAKE_SCOPED_LOCK_THREAD_LOCKED
-  // it doesn't leave the critical section, as opposed to ScopedCheck,
-  // because the critical section being pinned is allowed to be used only
-  // from one thread
-  class BASE_EXPORT Check {
-   public:
-    explicit Check(ThreadCollisionWarner* warner)
-        : warner_(warner) {
-      warner_->EnterSelf();
-    }
-
-    ~Check() {}
-
-   private:
-    ThreadCollisionWarner* warner_;
-
-    DISALLOW_COPY_AND_ASSIGN(Check);
-  };
-
-  // This class is meant to be used through the macro
-  // DFAKE_SCOPED_LOCK
-  class BASE_EXPORT ScopedCheck {
-   public:
-    explicit ScopedCheck(ThreadCollisionWarner* warner)
-        : warner_(warner) {
-      warner_->Enter();
-    }
-
-    ~ScopedCheck() {
-      warner_->Leave();
-    }
-
-   private:
-    ThreadCollisionWarner* warner_;
-
-    DISALLOW_COPY_AND_ASSIGN(ScopedCheck);
-  };
-
-  // This class is meant to be used through the macro
-  // DFAKE_SCOPED_RECURSIVE_LOCK
-  class BASE_EXPORT ScopedRecursiveCheck {
-   public:
-    explicit ScopedRecursiveCheck(ThreadCollisionWarner* warner)
-        : warner_(warner) {
-      warner_->EnterSelf();
-    }
-
-    ~ScopedRecursiveCheck() {
-      warner_->Leave();
-    }
-
-   private:
-    ThreadCollisionWarner* warner_;
-
-    DISALLOW_COPY_AND_ASSIGN(ScopedRecursiveCheck);
-  };
-
- private:
-  // This method stores the current thread identifier and does a DCHECK
-  // if a another thread has already done it, it is safe if same thread
-  // calls this multiple time (recursion allowed).
-  void EnterSelf();
-
-  // Same as EnterSelf but recursion is not allowed.
-  void Enter();
-
-  // Removes the thread_id stored in order to allow other threads to
-  // call EnterSelf or Enter.
-  void Leave();
-
-  // This stores the thread id that is inside the critical section, if the
-  // value is 0 then no thread is inside.
-  volatile subtle::Atomic32 valid_thread_id_;
-
-  // Counter to trace how many time a critical section was "pinned"
-  // (when allowed) in order to unpin it when counter_ reaches 0.
-  volatile subtle::Atomic32 counter_;
-
-  // Here only for class unit tests purpose, during the test I need to not
-  // DCHECK but notify the collision with something else.
-  AsserterBase* asserter_;
-
-  DISALLOW_COPY_AND_ASSIGN(ThreadCollisionWarner);
-};
-
-}  // namespace base
-
-#endif  // BASE_THREADING_THREAD_COLLISION_WARNER_H_
diff --git a/security/sandbox/chromium/base/threading/thread_id_name_manager.cc b/security/sandbox/chromium/base/threading/thread_id_name_manager.cc
deleted file mode 100644
index 56cfa273a..000000000
--- a/security/sandbox/chromium/base/threading/thread_id_name_manager.cc
+++ /dev/null
@@ -1,112 +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/threading/thread_id_name_manager.h"
-
-#include <stdlib.h>
-#include <string.h>
-
-#include "base/logging.h"
-#include "base/memory/singleton.h"
-#include "base/strings/string_util.h"
-
-namespace base {
-namespace {
-
-static const char kDefaultName[] = "";
-static std::string* g_default_name;
-
-}
-
-ThreadIdNameManager::ThreadIdNameManager()
-    : main_process_name_(NULL),
-      main_process_id_(kInvalidThreadId) {
-  g_default_name = new std::string(kDefaultName);
-
-  AutoLock locked(lock_);
-  name_to_interned_name_[kDefaultName] = g_default_name;
-}
-
-ThreadIdNameManager::~ThreadIdNameManager() {
-}
-
-ThreadIdNameManager* ThreadIdNameManager::GetInstance() {
-  return Singleton<ThreadIdNameManager,
-      LeakySingletonTraits<ThreadIdNameManager> >::get();
-}
-
-const char* ThreadIdNameManager::GetDefaultInternedString() {
-  return g_default_name->c_str();
-}
-
-void ThreadIdNameManager::RegisterThread(PlatformThreadHandle::Handle handle,
-                                         PlatformThreadId id) {
-  AutoLock locked(lock_);
-  thread_id_to_handle_[id] = handle;
-  thread_handle_to_interned_name_[handle] =
-      name_to_interned_name_[kDefaultName];
-}
-
-void ThreadIdNameManager::SetName(PlatformThreadId id,
-                                  const std::string& name) {
-  AutoLock locked(lock_);
-  NameToInternedNameMap::iterator iter = name_to_interned_name_.find(name);
-  std::string* leaked_str = NULL;
-  if (iter != name_to_interned_name_.end()) {
-    leaked_str = iter->second;
-  } else {
-    leaked_str = new std::string(name);
-    name_to_interned_name_[name] = leaked_str;
-  }
-
-  ThreadIdToHandleMap::iterator id_to_handle_iter =
-      thread_id_to_handle_.find(id);
-
-  // The main thread of a process will not be created as a Thread object which
-  // means there is no PlatformThreadHandler registered.
-  if (id_to_handle_iter == thread_id_to_handle_.end()) {
-    main_process_name_ = leaked_str;
-    main_process_id_ = id;
-    return;
-  }
-  thread_handle_to_interned_name_[id_to_handle_iter->second] = leaked_str;
-}
-
-const char* ThreadIdNameManager::GetName(PlatformThreadId id) {
-  AutoLock locked(lock_);
-
-  if (id == main_process_id_)
-    return main_process_name_->c_str();
-
-  ThreadIdToHandleMap::iterator id_to_handle_iter =
-      thread_id_to_handle_.find(id);
-  if (id_to_handle_iter == thread_id_to_handle_.end())
-    return name_to_interned_name_[kDefaultName]->c_str();
-
-  ThreadHandleToInternedNameMap::iterator handle_to_name_iter =
-      thread_handle_to_interned_name_.find(id_to_handle_iter->second);
-  return handle_to_name_iter->second->c_str();
-}
-
-void ThreadIdNameManager::RemoveName(PlatformThreadHandle::Handle handle,
-                                     PlatformThreadId id) {
-  AutoLock locked(lock_);
-  ThreadHandleToInternedNameMap::iterator handle_to_name_iter =
-      thread_handle_to_interned_name_.find(handle);
-
-  DCHECK(handle_to_name_iter != thread_handle_to_interned_name_.end());
-  thread_handle_to_interned_name_.erase(handle_to_name_iter);
-
-  ThreadIdToHandleMap::iterator id_to_handle_iter =
-      thread_id_to_handle_.find(id);
-  DCHECK((id_to_handle_iter!= thread_id_to_handle_.end()));
-  // The given |id| may have been re-used by the system. Make sure the
-  // mapping points to the provided |handle| before removal.
-  if (id_to_handle_iter->second != handle)
-    return;
-
-  thread_id_to_handle_.erase(id_to_handle_iter);
-}
-
-}  // namespace base
diff --git a/security/sandbox/chromium/base/threading/thread_id_name_manager.h b/security/sandbox/chromium/base/threading/thread_id_name_manager.h
deleted file mode 100644
index f469b605e..000000000
--- a/security/sandbox/chromium/base/threading/thread_id_name_manager.h
+++ /dev/null
@@ -1,68 +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.
-
-#ifndef BASE_THREADING_THREAD_ID_NAME_MANAGER_H_
-#define BASE_THREADING_THREAD_ID_NAME_MANAGER_H_
-
-#include <map>
-#include <string>
-
-#include "base/base_export.h"
-#include "base/macros.h"
-#include "base/synchronization/lock.h"
-#include "base/threading/platform_thread.h"
-
-namespace base {
-
-template <typename T>
-struct DefaultSingletonTraits;
-
-class BASE_EXPORT ThreadIdNameManager {
- public:
-  static ThreadIdNameManager* GetInstance();
-
-  static const char* GetDefaultInternedString();
-
-  // Register the mapping between a thread |id| and |handle|.
-  void RegisterThread(PlatformThreadHandle::Handle handle, PlatformThreadId id);
-
-  // Set the name for the given id.
-  void SetName(PlatformThreadId id, const std::string& name);
-
-  // Get the name for the given id.
-  const char* GetName(PlatformThreadId id);
-
-  // Remove the name for the given id.
-  void RemoveName(PlatformThreadHandle::Handle handle, PlatformThreadId id);
-
- private:
-  friend struct DefaultSingletonTraits<ThreadIdNameManager>;
-
-  typedef std::map<PlatformThreadId, PlatformThreadHandle::Handle>
-      ThreadIdToHandleMap;
-  typedef std::map<PlatformThreadHandle::Handle, std::string*>
-      ThreadHandleToInternedNameMap;
-  typedef std::map<std::string, std::string*> NameToInternedNameMap;
-
-  ThreadIdNameManager();
-  ~ThreadIdNameManager();
-
-  // lock_ protects the name_to_interned_name_, thread_id_to_handle_ and
-  // thread_handle_to_interned_name_ maps.
-  Lock lock_;
-
-  NameToInternedNameMap name_to_interned_name_;
-  ThreadIdToHandleMap thread_id_to_handle_;
-  ThreadHandleToInternedNameMap thread_handle_to_interned_name_;
-
-  // Treat the main process specially as there is no PlatformThreadHandle.
-  std::string* main_process_name_;
-  PlatformThreadId main_process_id_;
-
-  DISALLOW_COPY_AND_ASSIGN(ThreadIdNameManager);
-};
-
-}  // namespace base
-
-#endif  // BASE_THREADING_THREAD_ID_NAME_MANAGER_H_
diff --git a/security/sandbox/chromium/base/threading/thread_local.h b/security/sandbox/chromium/base/threading/thread_local.h
deleted file mode 100644
index f40420cd2..000000000
--- a/security/sandbox/chromium/base/threading/thread_local.h
+++ /dev/null
@@ -1,134 +0,0 @@
-// Copyright (c) 2011 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.
-
-// WARNING: Thread local storage is a bit tricky to get right.  Please make
-// sure that this is really the proper solution for what you're trying to
-// achieve.  Don't prematurely optimize, most likely you can just use a Lock.
-//
-// These classes implement a wrapper around the platform's TLS storage
-// mechanism.  On construction, they will allocate a TLS slot, and free the
-// TLS slot on destruction.  No memory management (creation or destruction) is
-// handled.  This means for uses of ThreadLocalPointer, you must correctly
-// manage the memory yourself, these classes will not destroy the pointer for
-// you.  There are no at-thread-exit actions taken by these classes.
-//
-// ThreadLocalPointer<Type> wraps a Type*.  It performs no creation or
-// destruction, so memory management must be handled elsewhere.  The first call
-// to Get() on a thread will return NULL.  You can update the pointer with a
-// call to Set().
-//
-// ThreadLocalBoolean wraps a bool.  It will default to false if it has never
-// been set otherwise with Set().
-//
-// Thread Safety:  An instance of ThreadLocalStorage is completely thread safe
-// once it has been created.  If you want to dynamically create an instance,
-// you must of course properly deal with safety and race conditions.  This
-// means a function-level static initializer is generally inappropiate.
-//
-// In Android, the system TLS is limited, the implementation is backed with
-// ThreadLocalStorage.
-//
-// Example usage:
-//   // My class is logically attached to a single thread.  We cache a pointer
-//   // on the thread it was created on, so we can implement current().
-//   MyClass::MyClass() {
-//     DCHECK(Singleton<ThreadLocalPointer<MyClass> >::get()->Get() == NULL);
-//     Singleton<ThreadLocalPointer<MyClass> >::get()->Set(this);
-//   }
-//
-//   MyClass::~MyClass() {
-//     DCHECK(Singleton<ThreadLocalPointer<MyClass> >::get()->Get() != NULL);
-//     Singleton<ThreadLocalPointer<MyClass> >::get()->Set(NULL);
-//   }
-//
-//   // Return the current MyClass associated with the calling thread, can be
-//   // NULL if there isn't a MyClass associated.
-//   MyClass* MyClass::current() {
-//     return Singleton<ThreadLocalPointer<MyClass> >::get()->Get();
-//   }
-
-#ifndef BASE_THREADING_THREAD_LOCAL_H_
-#define BASE_THREADING_THREAD_LOCAL_H_
-
-#include "base/base_export.h"
-#include "base/macros.h"
-#include "base/threading/thread_local_storage.h"
-#include "build/build_config.h"
-
-#if defined(OS_POSIX)
-#include <pthread.h>
-#endif
-
-namespace base {
-namespace internal {
-
-// Helper functions that abstract the cross-platform APIs.  Do not use directly.
-struct BASE_EXPORT ThreadLocalPlatform {
-#if defined(OS_WIN)
-  typedef unsigned long SlotType;
-#elif defined(OS_ANDROID)
-  typedef ThreadLocalStorage::StaticSlot SlotType;
-#elif defined(OS_POSIX)
-  typedef pthread_key_t SlotType;
-#endif
-
-  static void AllocateSlot(SlotType* slot);
-  static void FreeSlot(SlotType slot);
-  static void* GetValueFromSlot(SlotType slot);
-  static void SetValueInSlot(SlotType slot, void* value);
-};
-
-}  // namespace internal
-
-template <typename Type>
-class ThreadLocalPointer {
- public:
-  ThreadLocalPointer() : slot_() {
-    internal::ThreadLocalPlatform::AllocateSlot(&slot_);
-  }
-
-  ~ThreadLocalPointer() {
-    internal::ThreadLocalPlatform::FreeSlot(slot_);
-  }
-
-  Type* Get() {
-    return static_cast<Type*>(
-        internal::ThreadLocalPlatform::GetValueFromSlot(slot_));
-  }
-
-  void Set(Type* ptr) {
-    internal::ThreadLocalPlatform::SetValueInSlot(
-        slot_, const_cast<void*>(static_cast<const void*>(ptr)));
-  }
-
- private:
-  typedef internal::ThreadLocalPlatform::SlotType SlotType;
-
-  SlotType slot_;
-
-  DISALLOW_COPY_AND_ASSIGN(ThreadLocalPointer<Type>);
-};
-
-class ThreadLocalBoolean {
- public:
-  ThreadLocalBoolean() {}
-  ~ThreadLocalBoolean() {}
-
-  bool Get() {
-    return tlp_.Get() != NULL;
-  }
-
-  void Set(bool val) {
-    tlp_.Set(val ? this : NULL);
-  }
-
- private:
-  ThreadLocalPointer<void> tlp_;
-
-  DISALLOW_COPY_AND_ASSIGN(ThreadLocalBoolean);
-};
-
-}  // namespace base
-
-#endif  // BASE_THREADING_THREAD_LOCAL_H_
diff --git a/security/sandbox/chromium/base/threading/thread_local_posix.cc b/security/sandbox/chromium/base/threading/thread_local_posix.cc
deleted file mode 100644
index 8bc46ad19..000000000
--- a/security/sandbox/chromium/base/threading/thread_local_posix.cc
+++ /dev/null
@@ -1,43 +0,0 @@
-// Copyright (c) 2011 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/threading/thread_local.h"
-
-#include <pthread.h>
-
-#include "base/logging.h"
-#include "build/build_config.h"
-
-#if !defined(OS_ANDROID)
-
-namespace base {
-namespace internal {
-
-// static
-void ThreadLocalPlatform::AllocateSlot(SlotType* slot) {
-  int error = pthread_key_create(slot, NULL);
-  CHECK_EQ(error, 0);
-}
-
-// static
-void ThreadLocalPlatform::FreeSlot(SlotType slot) {
-  int error = pthread_key_delete(slot);
-  DCHECK_EQ(0, error);
-}
-
-// static
-void* ThreadLocalPlatform::GetValueFromSlot(SlotType slot) {
-  return pthread_getspecific(slot);
-}
-
-// static
-void ThreadLocalPlatform::SetValueInSlot(SlotType slot, void* value) {
-  int error = pthread_setspecific(slot, value);
-  DCHECK_EQ(error, 0);
-}
-
-}  // namespace internal
-}  // namespace base
-
-#endif  // !defined(OS_ANDROID)
diff --git a/security/sandbox/chromium/base/threading/thread_local_storage.h b/security/sandbox/chromium/base/threading/thread_local_storage.h
deleted file mode 100644
index 013b0aeff..000000000
--- a/security/sandbox/chromium/base/threading/thread_local_storage.h
+++ /dev/null
@@ -1,148 +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.
-
-#ifndef BASE_THREADING_THREAD_LOCAL_STORAGE_H_
-#define BASE_THREADING_THREAD_LOCAL_STORAGE_H_
-
-#include "base/atomicops.h"
-#include "base/base_export.h"
-#include "base/macros.h"
-#include "build/build_config.h"
-
-#if defined(OS_WIN)
-#include <windows.h>
-#elif defined(OS_POSIX)
-#include <pthread.h>
-#endif
-
-namespace base {
-
-namespace internal {
-
-// WARNING: You should *NOT* be using this class directly.
-// PlatformThreadLocalStorage is low-level abstraction to the OS's TLS
-// interface, you should instead be using ThreadLocalStorage::StaticSlot/Slot.
-class BASE_EXPORT PlatformThreadLocalStorage {
- public:
-
-#if defined(OS_WIN)
-  typedef unsigned long TLSKey;
-  enum : unsigned { TLS_KEY_OUT_OF_INDEXES = TLS_OUT_OF_INDEXES };
-#elif defined(OS_POSIX)
-  typedef pthread_key_t TLSKey;
-  // The following is a "reserved key" which is used in our generic Chromium
-  // ThreadLocalStorage implementation.  We expect that an OS will not return
-  // such a key, but if it is returned (i.e., the OS tries to allocate it) we
-  // will just request another key.
-  enum { TLS_KEY_OUT_OF_INDEXES = 0x7FFFFFFF };
-#endif
-
-  // The following methods need to be supported on each OS platform, so that
-  // the Chromium ThreadLocalStore functionality can be constructed.
-  // Chromium will use these methods to acquire a single OS slot, and then use
-  // that to support a much larger number of Chromium slots (independent of the
-  // OS restrictions).
-  // The following returns true if it successfully is able to return an OS
-  // key in |key|.
-  static bool AllocTLS(TLSKey* key);
-  // Note: FreeTLS() doesn't have to be called, it is fine with this leak, OS
-  // might not reuse released slot, you might just reset the TLS value with
-  // SetTLSValue().
-  static void FreeTLS(TLSKey key);
-  static void SetTLSValue(TLSKey key, void* value);
-  static void* GetTLSValue(TLSKey key);
-
-  // Each platform (OS implementation) is required to call this method on each
-  // terminating thread when the thread is about to terminate.  This method
-  // will then call all registered destructors for slots in Chromium
-  // ThreadLocalStorage, until there are no slot values remaining as having
-  // been set on this thread.
-  // Destructors may end up being called multiple times on a terminating
-  // thread, as other destructors may re-set slots that were previously
-  // destroyed.
-#if defined(OS_WIN)
-  // Since Windows which doesn't support TLS destructor, the implementation
-  // should use GetTLSValue() to retrieve the value of TLS slot.
-  static void OnThreadExit();
-#elif defined(OS_POSIX)
-  // |Value| is the data stored in TLS slot, The implementation can't use
-  // GetTLSValue() to retrieve the value of slot as it has already been reset
-  // in Posix.
-  static void OnThreadExit(void* value);
-#endif
-};
-
-}  // namespace internal
-
-// Wrapper for thread local storage.  This class doesn't do much except provide
-// an API for portability.
-class BASE_EXPORT ThreadLocalStorage {
- public:
-
-  // Prototype for the TLS destructor function, which can be optionally used to
-  // cleanup thread local storage on thread exit.  'value' is the data that is
-  // stored in thread local storage.
-  typedef void (*TLSDestructorFunc)(void* value);
-
-  // StaticSlot uses its own struct initializer-list style static
-  // initialization, as base's LINKER_INITIALIZED requires a constructor and on
-  // some compilers (notably gcc 4.4) this still ends up needing runtime
-  // initialization.
-  #define TLS_INITIALIZER {0}
-
-  // A key representing one value stored in TLS.
-  // Initialize like
-  //   ThreadLocalStorage::StaticSlot my_slot = TLS_INITIALIZER;
-  // If you're not using a static variable, use the convenience class
-  // ThreadLocalStorage::Slot (below) instead.
-  struct BASE_EXPORT StaticSlot {
-    // Set up the TLS slot.  Called by the constructor.
-    // 'destructor' is a pointer to a function to perform per-thread cleanup of
-    // this object.  If set to NULL, no cleanup is done for this TLS slot.
-    void Initialize(TLSDestructorFunc destructor);
-
-    // Free a previously allocated TLS 'slot'.
-    // If a destructor was set for this slot, removes
-    // the destructor so that remaining threads exiting
-    // will not free data.
-    void Free();
-
-    // Get the thread-local value stored in slot 'slot'.
-    // Values are guaranteed to initially be zero.
-    void* Get() const;
-
-    // Set the thread-local value stored in slot 'slot' to
-    // value 'value'.
-    void Set(void* value);
-
-    bool initialized() const {
-      return base::subtle::Acquire_Load(&initialized_) != 0;
-    }
-
-    // The internals of this struct should be considered private.
-    base::subtle::Atomic32 initialized_;
-    int slot_;
-  };
-
-  // A convenience wrapper around StaticSlot with a constructor. Can be used
-  // as a member variable.
-  class BASE_EXPORT Slot : public StaticSlot {
-   public:
-    // Calls StaticSlot::Initialize().
-    explicit Slot(TLSDestructorFunc destructor = NULL);
-
-   private:
-    using StaticSlot::initialized_;
-    using StaticSlot::slot_;
-
-    DISALLOW_COPY_AND_ASSIGN(Slot);
-  };
-
- private:
-  DISALLOW_COPY_AND_ASSIGN(ThreadLocalStorage);
-};
-
-}  // namespace base
-
-#endif  // BASE_THREADING_THREAD_LOCAL_STORAGE_H_
diff --git a/security/sandbox/chromium/base/threading/thread_local_win.cc b/security/sandbox/chromium/base/threading/thread_local_win.cc
deleted file mode 100644
index 1c74e4213..000000000
--- a/security/sandbox/chromium/base/threading/thread_local_win.cc
+++ /dev/null
@@ -1,40 +0,0 @@
-// Copyright (c) 2010 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/threading/thread_local.h"
-
-#include <windows.h>
-
-#include "base/logging.h"
-
-namespace base {
-namespace internal {
-
-// static
-void ThreadLocalPlatform::AllocateSlot(SlotType* slot) {
-  *slot = TlsAlloc();
-  CHECK_NE(*slot, TLS_OUT_OF_INDEXES);
-}
-
-// static
-void ThreadLocalPlatform::FreeSlot(SlotType slot) {
-  if (!TlsFree(slot)) {
-    NOTREACHED() << "Failed to deallocate tls slot with TlsFree().";
-  }
-}
-
-// static
-void* ThreadLocalPlatform::GetValueFromSlot(SlotType slot) {
-  return TlsGetValue(slot);
-}
-
-// static
-void ThreadLocalPlatform::SetValueInSlot(SlotType slot, void* value) {
-  if (!TlsSetValue(slot, value)) {
-    LOG(FATAL) << "Failed to TlsSetValue().";
-  }
-}
-
-}  // namespace internal
-}  // namespace base
diff --git a/security/sandbox/chromium/base/threading/thread_restrictions.cc b/security/sandbox/chromium/base/threading/thread_restrictions.cc
deleted file mode 100644
index 00306c5ae..000000000
--- a/security/sandbox/chromium/base/threading/thread_restrictions.cc
+++ /dev/null
@@ -1,85 +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/threading/thread_restrictions.h"
-
-#if ENABLE_THREAD_RESTRICTIONS
-
-#include "base/lazy_instance.h"
-#include "base/logging.h"
-#include "base/threading/thread_local.h"
-
-namespace base {
-
-namespace {
-
-LazyInstance<ThreadLocalBoolean>::Leaky
-    g_io_disallowed = LAZY_INSTANCE_INITIALIZER;
-
-LazyInstance<ThreadLocalBoolean>::Leaky
-    g_singleton_disallowed = LAZY_INSTANCE_INITIALIZER;
-
-LazyInstance<ThreadLocalBoolean>::Leaky
-    g_wait_disallowed = LAZY_INSTANCE_INITIALIZER;
-
-}  // namespace
-
-// static
-bool ThreadRestrictions::SetIOAllowed(bool allowed) {
-  bool previous_disallowed = g_io_disallowed.Get().Get();
-  g_io_disallowed.Get().Set(!allowed);
-  return !previous_disallowed;
-}
-
-// static
-void ThreadRestrictions::AssertIOAllowed() {
-  if (g_io_disallowed.Get().Get()) {
-    LOG(FATAL) <<
-        "Function marked as IO-only was called from a thread that "
-        "disallows IO!  If this thread really should be allowed to "
-        "make IO calls, adjust the call to "
-        "base::ThreadRestrictions::SetIOAllowed() in this thread's "
-        "startup.";
-  }
-}
-
-// static
-bool ThreadRestrictions::SetSingletonAllowed(bool allowed) {
-  bool previous_disallowed = g_singleton_disallowed.Get().Get();
-  g_singleton_disallowed.Get().Set(!allowed);
-  return !previous_disallowed;
-}
-
-// static
-void ThreadRestrictions::AssertSingletonAllowed() {
-  if (g_singleton_disallowed.Get().Get()) {
-    LOG(FATAL) << "LazyInstance/Singleton is not allowed to be used on this "
-               << "thread.  Most likely it's because this thread is not "
-               << "joinable, so AtExitManager may have deleted the object "
-               << "on shutdown, leading to a potential shutdown crash.";
-  }
-}
-
-// static
-void ThreadRestrictions::DisallowWaiting() {
-  g_wait_disallowed.Get().Set(true);
-}
-
-// static
-void ThreadRestrictions::AssertWaitAllowed() {
-  if (g_wait_disallowed.Get().Get()) {
-    LOG(FATAL) << "Waiting is not allowed to be used on this thread to prevent "
-               << "jank and deadlock.";
-  }
-}
-
-bool ThreadRestrictions::SetWaitAllowed(bool allowed) {
-  bool previous_disallowed = g_wait_disallowed.Get().Get();
-  g_wait_disallowed.Get().Set(!allowed);
-  return !previous_disallowed;
-}
-
-}  // namespace base
-
-#endif  // ENABLE_THREAD_RESTRICTIONS
diff --git a/security/sandbox/chromium/base/threading/thread_restrictions.h b/security/sandbox/chromium/base/threading/thread_restrictions.h
deleted file mode 100644
index eec00fbb7..000000000
--- a/security/sandbox/chromium/base/threading/thread_restrictions.h
+++ /dev/null
@@ -1,266 +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.
-
-#ifndef BASE_THREADING_THREAD_RESTRICTIONS_H_
-#define BASE_THREADING_THREAD_RESTRICTIONS_H_
-
-#include "base/base_export.h"
-#include "base/macros.h"
-
-// See comment at top of thread_checker.h
-#if (!defined(NDEBUG) || defined(DCHECK_ALWAYS_ON))
-#define ENABLE_THREAD_RESTRICTIONS 1
-#else
-#define ENABLE_THREAD_RESTRICTIONS 0
-#endif
-
-class BrowserProcessImpl;
-class HistogramSynchronizer;
-class NativeBackendKWallet;
-class ScopedAllowWaitForLegacyWebViewApi;
-
-namespace cc {
-class CompletionEvent;
-class SingleThreadTaskGraphRunner;
-}
-namespace chromeos {
-class BlockingMethodCaller;
-namespace system {
-class StatisticsProviderImpl;
-}
-}
-namespace chrome_browser_net {
-class Predictor;
-}
-namespace content {
-class BrowserGpuChannelHostFactory;
-class BrowserGpuMemoryBufferManager;
-class BrowserShutdownProfileDumper;
-class BrowserTestBase;
-class GpuChannelHost;
-class NestedMessagePumpAndroid;
-class ScopedAllowWaitForAndroidLayoutTests;
-class ScopedAllowWaitForDebugURL;
-class SoftwareOutputDeviceMus;
-class TextInputClientMac;
-class RasterWorkerPool;
-}  // namespace content
-namespace dbus {
-class Bus;
-}
-namespace disk_cache {
-class BackendImpl;
-class InFlightIO;
-}
-namespace gles2 {
-class CommandBufferClientImpl;
-}
-namespace mojo {
-namespace common {
-class MessagePumpMojo;
-}
-}
-namespace mus {
-class CommandBufferLocal;
-class GpuState;
-}
-namespace net {
-class NetworkChangeNotifierMac;
-namespace internal {
-class AddressTrackerLinux;
-}
-}
-
-namespace remoting {
-class AutoThread;
-}
-
-namespace ui {
-class WindowResizeHelperMac;
-}
-
-namespace views {
-class WindowManagerConnection;
-}
-
-namespace base {
-
-namespace android {
-class JavaHandlerThread;
-}
-
-class SequencedWorkerPool;
-class SimpleThread;
-class Thread;
-class ThreadTestHelper;
-
-// Certain behavior is disallowed on certain threads.  ThreadRestrictions helps
-// enforce these rules.  Examples of such rules:
-//
-// * Do not do blocking IO (makes the thread janky)
-// * Do not access Singleton/LazyInstance (may lead to shutdown crashes)
-//
-// Here's more about how the protection works:
-//
-// 1) If a thread should not be allowed to make IO calls, mark it:
-//      base::ThreadRestrictions::SetIOAllowed(false);
-//    By default, threads *are* allowed to make IO calls.
-//    In Chrome browser code, IO calls should be proxied to the File thread.
-//
-// 2) If a function makes a call that will go out to disk, check whether the
-//    current thread is allowed:
-//      base::ThreadRestrictions::AssertIOAllowed();
-//
-//
-// Style tip: where should you put AssertIOAllowed checks?  It's best
-// if you put them as close to the disk access as possible, at the
-// lowest level.  This rule is simple to follow and helps catch all
-// callers.  For example, if your function GoDoSomeBlockingDiskCall()
-// only calls other functions in Chrome and not fopen(), you should go
-// add the AssertIOAllowed checks in the helper functions.
-
-class BASE_EXPORT ThreadRestrictions {
- public:
-  // Constructing a ScopedAllowIO temporarily allows IO for the current
-  // thread.  Doing this is almost certainly always incorrect.
-  class BASE_EXPORT ScopedAllowIO {
-   public:
-    ScopedAllowIO() { previous_value_ = SetIOAllowed(true); }
-    ~ScopedAllowIO() { SetIOAllowed(previous_value_); }
-   private:
-    // Whether IO is allowed when the ScopedAllowIO was constructed.
-    bool previous_value_;
-
-    DISALLOW_COPY_AND_ASSIGN(ScopedAllowIO);
-  };
-
-  // Constructing a ScopedAllowSingleton temporarily allows accessing for the
-  // current thread.  Doing this is almost always incorrect.
-  class BASE_EXPORT ScopedAllowSingleton {
-   public:
-    ScopedAllowSingleton() { previous_value_ = SetSingletonAllowed(true); }
-    ~ScopedAllowSingleton() { SetSingletonAllowed(previous_value_); }
-   private:
-    // Whether singleton use is allowed when the ScopedAllowSingleton was
-    // constructed.
-    bool previous_value_;
-
-    DISALLOW_COPY_AND_ASSIGN(ScopedAllowSingleton);
-  };
-
-#if ENABLE_THREAD_RESTRICTIONS
-  // Set whether the current thread to make IO calls.
-  // Threads start out in the *allowed* state.
-  // Returns the previous value.
-  static bool SetIOAllowed(bool allowed);
-
-  // Check whether the current thread is allowed to make IO calls,
-  // and DCHECK if not.  See the block comment above the class for
-  // a discussion of where to add these checks.
-  static void AssertIOAllowed();
-
-  // Set whether the current thread can use singletons.  Returns the previous
-  // value.
-  static bool SetSingletonAllowed(bool allowed);
-
-  // Check whether the current thread is allowed to use singletons (Singleton /
-  // LazyInstance).  DCHECKs if not.
-  static void AssertSingletonAllowed();
-
-  // Disable waiting on the current thread. Threads start out in the *allowed*
-  // state. Returns the previous value.
-  static void DisallowWaiting();
-
-  // Check whether the current thread is allowed to wait, and DCHECK if not.
-  static void AssertWaitAllowed();
-#else
-  // Inline the empty definitions of these functions so that they can be
-  // compiled out.
-  static bool SetIOAllowed(bool allowed) { return true; }
-  static void AssertIOAllowed() {}
-  static bool SetSingletonAllowed(bool allowed) { return true; }
-  static void AssertSingletonAllowed() {}
-  static void DisallowWaiting() {}
-  static void AssertWaitAllowed() {}
-#endif
-
- private:
-  // DO NOT ADD ANY OTHER FRIEND STATEMENTS, talk to jam or brettw first.
-  // BEGIN ALLOWED USAGE.
-  friend class content::BrowserShutdownProfileDumper;
-  friend class content::BrowserTestBase;
-  friend class content::NestedMessagePumpAndroid;
-  friend class content::ScopedAllowWaitForAndroidLayoutTests;
-  friend class content::ScopedAllowWaitForDebugURL;
-  friend class ::HistogramSynchronizer;
-  friend class ::ScopedAllowWaitForLegacyWebViewApi;
-  friend class cc::CompletionEvent;
-  friend class cc::SingleThreadTaskGraphRunner;
-  friend class content::RasterWorkerPool;
-  friend class remoting::AutoThread;
-  friend class ui::WindowResizeHelperMac;
-  friend class MessagePumpDefault;
-  friend class SequencedWorkerPool;
-  friend class SimpleThread;
-  friend class Thread;
-  friend class ThreadTestHelper;
-  friend class PlatformThread;
-  friend class android::JavaHandlerThread;
-  friend class gles2::CommandBufferClientImpl;
-  friend class mojo::common::MessagePumpMojo;
-  friend class mus::CommandBufferLocal;
-  friend class mus::GpuState;
-
-  // END ALLOWED USAGE.
-  // BEGIN USAGE THAT NEEDS TO BE FIXED.
-  friend class ::chromeos::BlockingMethodCaller;  // http://crbug.com/125360
-  friend class ::chromeos::system::StatisticsProviderImpl;  // http://crbug.com/125385
-  friend class chrome_browser_net::Predictor;     // http://crbug.com/78451
-  friend class
-      content::BrowserGpuChannelHostFactory;      // http://crbug.com/125248
-  friend class
-      content::BrowserGpuMemoryBufferManager;     // http://crbug.com/420368
-  friend class content::GpuChannelHost;           // http://crbug.com/125264
-  friend class content::TextInputClientMac;       // http://crbug.com/121917
-  friend class dbus::Bus;                         // http://crbug.com/125222
-  friend class disk_cache::BackendImpl;           // http://crbug.com/74623
-  friend class disk_cache::InFlightIO;            // http://crbug.com/74623
-  friend class net::internal::AddressTrackerLinux;  // http://crbug.com/125097
-  friend class net::NetworkChangeNotifierMac;     // http://crbug.com/125097
-  friend class ::BrowserProcessImpl;              // http://crbug.com/125207
-  friend class ::NativeBackendKWallet;            // http://crbug.com/125331
-#if !defined(OFFICIAL_BUILD)
-  friend class content::SoftwareOutputDeviceMus;  // Interim non-production code
-#endif
-  friend class views::WindowManagerConnection;
-// END USAGE THAT NEEDS TO BE FIXED.
-
-#if ENABLE_THREAD_RESTRICTIONS
-  static bool SetWaitAllowed(bool allowed);
-#else
-  static bool SetWaitAllowed(bool allowed) { return true; }
-#endif
-
-  // Constructing a ScopedAllowWait temporarily allows waiting on the current
-  // thread.  Doing this is almost always incorrect, which is why we limit who
-  // can use this through friend. If you find yourself needing to use this, find
-  // another way. Talk to jam or brettw.
-  class BASE_EXPORT ScopedAllowWait {
-   public:
-    ScopedAllowWait() { previous_value_ = SetWaitAllowed(true); }
-    ~ScopedAllowWait() { SetWaitAllowed(previous_value_); }
-   private:
-    // Whether singleton use is allowed when the ScopedAllowWait was
-    // constructed.
-    bool previous_value_;
-
-    DISALLOW_COPY_AND_ASSIGN(ScopedAllowWait);
-  };
-
-  DISALLOW_IMPLICIT_CONSTRUCTORS(ThreadRestrictions);
-};
-
-}  // namespace base
-
-#endif  // BASE_THREADING_THREAD_RESTRICTIONS_H_