Move base to DEPS

base/lazy_instance_unittest.cc

Index: base/lazy_instance_unittest.cc
diff --git a/base/lazy_instance_unittest.cc b/base/lazy_instance_unittest.cc
deleted file mode 100644
index ec9ef2673207e8734bb900008c1e1cc368d416a5..0000000000000000000000000000000000000000
--- a/base/lazy_instance_unittest.cc
+++ /dev/null
@@ -1,172 +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/at_exit.h"
-#include "base/atomic_sequence_num.h"
-#include "base/lazy_instance.h"
-#include "base/memory/aligned_memory.h"
-#include "base/threading/simple_thread.h"
-#include "testing/gtest/include/gtest/gtest.h"
-
-namespace {
-
-base::StaticAtomicSequenceNumber constructed_seq_;
-base::StaticAtomicSequenceNumber destructed_seq_;
-
-class ConstructAndDestructLogger {
- public:
-  ConstructAndDestructLogger() {
-    constructed_seq_.GetNext();
-  }
-  ~ConstructAndDestructLogger() {
-    destructed_seq_.GetNext();
-  }
-};
-
-class SlowConstructor {
- public:
-  SlowConstructor() : some_int_(0) {
-    // Sleep for 1 second to try to cause a race.
-    base::PlatformThread::Sleep(base::TimeDelta::FromSeconds(1));
-    ++constructed;
-    some_int_ = 12;
-  }
-  int some_int() const { return some_int_; }
-
-  static int constructed;
- private:
-  int some_int_;
-};
-
-int SlowConstructor::constructed = 0;
-
-class SlowDelegate : public base::DelegateSimpleThread::Delegate {
- public:
-  explicit SlowDelegate(base::LazyInstance<SlowConstructor>* lazy)
-      : lazy_(lazy) {}
-
-  void Run() override {
-    EXPECT_EQ(12, lazy_->Get().some_int());
-    EXPECT_EQ(12, lazy_->Pointer()->some_int());
-  }
-
- private:
-  base::LazyInstance<SlowConstructor>* lazy_;
-};
-
-}  // namespace
-
-static base::LazyInstance<ConstructAndDestructLogger> lazy_logger =
-    LAZY_INSTANCE_INITIALIZER;
-
-TEST(LazyInstanceTest, Basic) {
-  {
-    base::ShadowingAtExitManager shadow;
-
-    EXPECT_EQ(0, constructed_seq_.GetNext());
-    EXPECT_EQ(0, destructed_seq_.GetNext());
-
-    lazy_logger.Get();
-    EXPECT_EQ(2, constructed_seq_.GetNext());
-    EXPECT_EQ(1, destructed_seq_.GetNext());
-
-    lazy_logger.Pointer();
-    EXPECT_EQ(3, constructed_seq_.GetNext());
-    EXPECT_EQ(2, destructed_seq_.GetNext());
-  }
-  EXPECT_EQ(4, constructed_seq_.GetNext());
-  EXPECT_EQ(4, destructed_seq_.GetNext());
-}
-
-static base::LazyInstance<SlowConstructor> lazy_slow =
-    LAZY_INSTANCE_INITIALIZER;
-
-TEST(LazyInstanceTest, ConstructorThreadSafety) {
-  {
-    base::ShadowingAtExitManager shadow;
-
-    SlowDelegate delegate(&lazy_slow);
-    EXPECT_EQ(0, SlowConstructor::constructed);
-
-    base::DelegateSimpleThreadPool pool("lazy_instance_cons", 5);
-    pool.AddWork(&delegate, 20);
-    EXPECT_EQ(0, SlowConstructor::constructed);
-
-    pool.Start();
-    pool.JoinAll();
-    EXPECT_EQ(1, SlowConstructor::constructed);
-  }
-}
-
-namespace {
-
-// DeleteLogger is an object which sets a flag when it's destroyed.
-// It accepts a bool* and sets the bool to true when the dtor runs.
-class DeleteLogger {
- public:
-  DeleteLogger() : deleted_(NULL) {}
-  ~DeleteLogger() { *deleted_ = true; }
-
-  void SetDeletedPtr(bool* deleted) {
-    deleted_ = deleted;
-  }
-
- private:
-  bool* deleted_;
-};
-
-}  // anonymous namespace
-
-TEST(LazyInstanceTest, LeakyLazyInstance) {
-  // Check that using a plain LazyInstance causes the dtor to run
-  // when the AtExitManager finishes.
-  bool deleted1 = false;
-  {
-    base::ShadowingAtExitManager shadow;
-    static base::LazyInstance<DeleteLogger> test = LAZY_INSTANCE_INITIALIZER;
-    test.Get().SetDeletedPtr(&deleted1);
-  }
-  EXPECT_TRUE(deleted1);
-
-  // Check that using a *leaky* LazyInstance makes the dtor not run
-  // when the AtExitManager finishes.
-  bool deleted2 = false;
-  {
-    base::ShadowingAtExitManager shadow;
-    static base::LazyInstance<DeleteLogger>::Leaky
-        test = LAZY_INSTANCE_INITIALIZER;
-    test.Get().SetDeletedPtr(&deleted2);
-  }
-  EXPECT_FALSE(deleted2);
-}
-
-namespace {
-
-template <size_t alignment>
-class AlignedData {
- public:
-  AlignedData() {}
-  ~AlignedData() {}
-  base::AlignedMemory<alignment, alignment> data_;
-};
-
-}  // anonymous namespace
-
-#define EXPECT_ALIGNED(ptr, align) \
-    EXPECT_EQ(0u, reinterpret_cast<uintptr_t>(ptr) & (align - 1))
-
-TEST(LazyInstanceTest, Alignment) {
-  using base::LazyInstance;
-
-  // Create some static instances with increasing sizes and alignment
-  // requirements. By ordering this way, the linker will need to do some work to
-  // ensure proper alignment of the static data.
-  static LazyInstance<AlignedData<4> > align4 = LAZY_INSTANCE_INITIALIZER;
-  static LazyInstance<AlignedData<32> > align32 = LAZY_INSTANCE_INITIALIZER;
-  static LazyInstance<AlignedData<4096> > align4096 = LAZY_INSTANCE_INITIALIZER;
-
-  EXPECT_ALIGNED(align4.Pointer(), 4);
-  EXPECT_ALIGNED(align32.Pointer(), 32);
-  EXPECT_ALIGNED(align4096.Pointer(), 4096);
-}