Convert //chrome/browser/ui from scoped_ptr to std::unique_ptr

chrome/browser/ui/app_list/search/history_unittest.cc

 // Copyright 2013 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 <stddef.h>
 
+#include <memory>
+
 #include "base/bind.h"
 #include "base/files/scoped_temp_dir.h"
 #include "base/macros.h"
-#include "base/memory/scoped_ptr.h"
 #include "base/message_loop/message_loop.h"
 #include "base/run_loop.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/test/sequenced_worker_pool_owner.h"
 #include "base/threading/platform_thread.h"
 #include "chrome/browser/ui/app_list/search/history_factory.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "ui/app_list/search/dictionary_data_store.h"
 #include "ui/app_list/search/history.h"
 #include "ui/app_list/search/history_data.h"
@@ skipping 24 matching lines @@
     run_loop_->Run();
 
     data_->RemoveObserver(this);
   }
 
  private:
   // HistoryDataObserver overrides:
   void OnHistoryDataLoadedFromStore() override { run_loop_->Quit(); }
 
   HistoryData* data_;  // Not owned.
-  scoped_ptr<base::RunLoop> run_loop_;
+  std::unique_ptr<base::RunLoop> run_loop_;
 
   DISALLOW_COPY_AND_ASSIGN(HistoryDataLoadWaiter);
 };
 
 // StoreFlushWaiter waits for the given |store| to flush its data to disk.
 // The flush and disk write happens on the blocking pool. The waiter waits
 // on the main message loop until the OnFlushed() is invoked or the maximum
 // allowed wait time has passed.
 class StoreFlushWaiter {
  public:
   explicit StoreFlushWaiter(HistoryDataStore* store) : store_(store) {}
   ~StoreFlushWaiter() {}
 
   void Wait() {
     store_->Flush(
         base::Bind(&StoreFlushWaiter::OnFlushed, base::Unretained(this)));
 
     run_loop_.reset(new base::RunLoop);
     run_loop_->Run();
   }
 
  private:
   void OnFlushed() {
     run_loop_->Quit();
   }
 
   HistoryDataStore* store_;  // Not owned.
-  scoped_ptr<base::RunLoop> run_loop_;
+  std::unique_ptr<base::RunLoop> run_loop_;
 
   DISALLOW_COPY_AND_ASSIGN(StoreFlushWaiter);
 };
 
 }  // namespace
 
 class SearchHistoryTest : public testing::Test {
  public:
   SearchHistoryTest() {}
   ~SearchHistoryTest() override {}
@@ skipping 44 matching lines @@
   }
 
   History* history() { return history_.get(); }
   const HistoryData::Associations& associations() const {
     return history_->data_->associations();
   }
 
  private:
   base::MessageLoopForUI message_loop_;
   base::ScopedTempDir temp_dir_;
-  scoped_ptr<base::SequencedWorkerPoolOwner> worker_pool_owner_;
+  std::unique_ptr<base::SequencedWorkerPoolOwner> worker_pool_owner_;
 
-  scoped_ptr<History> history_;
-  scoped_ptr<KnownResults> known_results_;
+  std::unique_ptr<History> history_;
+  std::unique_ptr<KnownResults> known_results_;
 
   DISALLOW_COPY_AND_ASSIGN(SearchHistoryTest);
 };
 
 TEST_F(SearchHistoryTest, Persistence) {
   // Ensure it's empty.
   EXPECT_EQ(0u, GetKnownResults("cal"));
 
   // Add one launch event.
   history()->AddLaunchEvent("cal", "calendar");
@@ skipping 133 matching lines @@
 
   // The oldest secondary is gone.
   EXPECT_EQ(UNKNOWN_RESULT, GetResultType("1"));
 
   // Touched oldest survived.
   EXPECT_EQ(PERFECT_SECONDARY, GetResultType("0"));
 }
 
 }  // namespace test
 }  // namespace app_list