Convert //extensions/browser/api from scoped_ptr to std::unique_ptr

extensions/browser/api/idle/idle_api_unittest.cc

 // 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 "extensions/browser/api/idle/idle_api.h"
 
 #include <limits.h>
+
+#include <memory>
 #include <string>
 
-#include "base/memory/scoped_ptr.h"
+#include "base/memory/ptr_util.h"
 #include "base/strings/string_number_conversions.h"
 #include "extensions/browser/api/idle/idle_api_constants.h"
+#include "extensions/browser/api/idle/idle_manager.h"
 #include "extensions/browser/api/idle/idle_manager_factory.h"
-#include "extensions/browser/api/idle/idle_manager.h"
 #include "extensions/browser/api_unittest.h"
 #include "extensions/browser/event_router.h"
 #include "extensions/browser/extension_registry.h"
 #include "extensions/common/api/idle.h"
 #include "extensions/common/extension.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 using ::testing::_;
 
@@ skipping 80 matching lines @@
                                   extension_id_, GURL(), NULL);
   idle_manager_->OnListenerAdded(details);
 }
 
 ScopedListen::~ScopedListen() {
   const EventListenerInfo details(idle::OnStateChanged::kEventName,
                                   extension_id_, GURL(), NULL);
   idle_manager_->OnListenerRemoved(details);
 }
 
-scoped_ptr<KeyedService> IdleManagerTestFactory(
+std::unique_ptr<KeyedService> IdleManagerTestFactory(
     content::BrowserContext* context) {
-  return make_scoped_ptr(new IdleManager(context));
+  return base::WrapUnique(new IdleManager(context));
 }
 
 }  // namespace
 
 class IdleTest : public ApiUnitTest {
  public:
   void SetUp() override;
 
  protected:
   IdleManager* idle_manager_;
   TestIdleProvider* idle_provider_;
   testing::StrictMock<MockEventDelegate>* event_delegate_;
 };
 
 void IdleTest::SetUp() {
   ApiUnitTest::SetUp();
 
   IdleManagerFactory::GetInstance()->SetTestingFactory(browser_context(),
                                                        &IdleManagerTestFactory);
   idle_manager_ = IdleManagerFactory::GetForBrowserContext(browser_context());
 
   idle_provider_ = new TestIdleProvider();
   idle_manager_->SetIdleTimeProviderForTest(
-      scoped_ptr<IdleManager::IdleTimeProvider>(idle_provider_));
+      std::unique_ptr<IdleManager::IdleTimeProvider>(idle_provider_));
   event_delegate_ = new testing::StrictMock<MockEventDelegate>();
   idle_manager_->SetEventDelegateForTest(
-      scoped_ptr<IdleManager::EventDelegate>(event_delegate_));
+      std::unique_ptr<IdleManager::EventDelegate>(event_delegate_));
   idle_manager_->Init();
 }
 
 // Verifies that "locked" takes priority over "active".
 TEST_F(IdleTest, QueryLockedActive) {
   idle_provider_->set_locked(true);
   idle_provider_->set_idle_time(0);
 
-  scoped_ptr<base::Value> result(
+  std::unique_ptr<base::Value> result(
       RunFunctionAndReturnValue(new IdleQueryStateFunction(), "[60]"));
 
   std::string idle_state;
   ASSERT_TRUE(result->GetAsString(&idle_state));
   EXPECT_EQ("locked", idle_state);
 }
 
 // Verifies that "locked" takes priority over "idle".
 TEST_F(IdleTest, QueryLockedIdle) {
   idle_provider_->set_locked(true);
   idle_provider_->set_idle_time(INT_MAX);
 
-  scoped_ptr<base::Value> result(
+  std::unique_ptr<base::Value> result(
       RunFunctionAndReturnValue(new IdleQueryStateFunction(), "[60]"));
 
   std::string idle_state;
   ASSERT_TRUE(result->GetAsString(&idle_state));
   EXPECT_EQ("locked", idle_state);
 }
 
 // Verifies that any amount of idle time less than the detection interval
 // translates to a state of "active".
 TEST_F(IdleTest, QueryActive) {
   idle_provider_->set_locked(false);
 
   for (int time = 0; time < 60; ++time) {
     SCOPED_TRACE(time);
     idle_provider_->set_idle_time(time);
 
-    scoped_ptr<base::Value> result(
+    std::unique_ptr<base::Value> result(
         RunFunctionAndReturnValue(new IdleQueryStateFunction(), "[60]"));
 
     std::string idle_state;
     ASSERT_TRUE(result->GetAsString(&idle_state));
     EXPECT_EQ("active", idle_state);
   }
 }
 
 // Verifies that an idle time >= the detection interval returns the "idle"
 // state.
 TEST_F(IdleTest, QueryIdle) {
   idle_provider_->set_locked(false);
 
   for (int time = 80; time >= 60; --time) {
     SCOPED_TRACE(time);
     idle_provider_->set_idle_time(time);
 
-    scoped_ptr<base::Value> result(
+    std::unique_ptr<base::Value> result(
         RunFunctionAndReturnValue(new IdleQueryStateFunction(), "[60]"));
 
     std::string idle_state;
     ASSERT_TRUE(result->GetAsString(&idle_state));
     EXPECT_EQ("idle", idle_state);
   }
 }
 
 // Verifies that requesting a detection interval < 15 has the same effect as
 // passing in 15.
 TEST_F(IdleTest, QueryMinThreshold) {
   idle_provider_->set_locked(false);
 
   for (int threshold = 0; threshold < 20; ++threshold) {
     for (int time = 10; time < 60; ++time) {
       SCOPED_TRACE(threshold);
       SCOPED_TRACE(time);
       idle_provider_->set_idle_time(time);
 
       std::string args = "[" + base::IntToString(threshold) + "]";
-      scoped_ptr<base::Value> result(
+      std::unique_ptr<base::Value> result(
           RunFunctionAndReturnValue(new IdleQueryStateFunction(), args));
 
       std::string idle_state;
       ASSERT_TRUE(result->GetAsString(&idle_state));
 
       int real_threshold = (threshold < 15) ? 15 : threshold;
       const char* expected = (time < real_threshold) ? "active" : "idle";
       EXPECT_EQ(expected, idle_state);
     }
   }
 }
 
 // Verifies that passing in a detection interval > 4 hours has the same effect
 // as passing in 4 hours.
 TEST_F(IdleTest, QueryMaxThreshold) {
   idle_provider_->set_locked(false);
 
   const int kFourHoursInSeconds = 4 * 60 * 60;
 
   for (int threshold = kFourHoursInSeconds - 20;
        threshold < (kFourHoursInSeconds + 20); ++threshold) {
     for (int time = kFourHoursInSeconds - 30; time < kFourHoursInSeconds + 30;
          ++time) {
       SCOPED_TRACE(threshold);
       SCOPED_TRACE(time);
       idle_provider_->set_idle_time(time);
 
       std::string args = "[" + base::IntToString(threshold) + "]";
-      scoped_ptr<base::Value> result(
+      std::unique_ptr<base::Value> result(
           RunFunctionAndReturnValue(new IdleQueryStateFunction(), args));
 
       std::string idle_state;
       ASSERT_TRUE(result->GetAsString(&idle_state));
 
       int real_threshold =
           (threshold > kFourHoursInSeconds) ? kFourHoursInSeconds : threshold;
       const char* expected = (time < real_threshold) ? "active" : "idle";
       EXPECT_EQ(expected, idle_state);
     }
@@ skipping 130 matching lines @@
   idle_manager_->UpdateIdleState();
 }
 
 // Verifies that setDetectionInterval changes the detection interval from the
 // default of 60 seconds, and that the call only affects a single extension's
 // IdleMonitor.
 TEST_F(IdleTest, SetDetectionInterval) {
   ScopedListen listen_default(idle_manager_, "default");
   ScopedListen listen_extension(idle_manager_, extension()->id());
 
-  scoped_ptr<base::Value> result45(RunFunctionAndReturnValue(
+  std::unique_ptr<base::Value> result45(RunFunctionAndReturnValue(
       new IdleSetDetectionIntervalFunction(), "[45]"));
 
   idle_provider_->set_locked(false);
   idle_provider_->set_idle_time(44);
   idle_manager_->UpdateIdleState();
 
   idle_provider_->set_idle_time(45);
   EXPECT_CALL(*event_delegate_,
               OnStateChanged(extension()->id(), ui::IDLE_STATE_IDLE));
   idle_manager_->UpdateIdleState();
   // Verify that the expectation has been fulfilled before incrementing the
   // time again.
   testing::Mock::VerifyAndClearExpectations(event_delegate_);
 
   idle_provider_->set_idle_time(60);
   EXPECT_CALL(*event_delegate_, OnStateChanged("default", ui::IDLE_STATE_IDLE));
   idle_manager_->UpdateIdleState();
 }
 
 // Verifies that setting the detection interval before creating the listener
 // works correctly.
 TEST_F(IdleTest, SetDetectionIntervalBeforeListener) {
-  scoped_ptr<base::Value> result45(RunFunctionAndReturnValue(
+  std::unique_ptr<base::Value> result45(RunFunctionAndReturnValue(
       new IdleSetDetectionIntervalFunction(), "[45]"));
 
   ScopedListen listen_extension(idle_manager_, extension()->id());
 
   idle_provider_->set_locked(false);
   idle_provider_->set_idle_time(44);
   idle_manager_->UpdateIdleState();
 
   idle_provider_->set_idle_time(45);
   EXPECT_CALL(*event_delegate_,
               OnStateChanged(extension()->id(), ui::IDLE_STATE_IDLE));
   idle_manager_->UpdateIdleState();
 }
 
 // Verifies that setting a detection interval above the maximum value results
 // in an interval of 4 hours.
 TEST_F(IdleTest, SetDetectionIntervalMaximum) {
   ScopedListen listen_extension(idle_manager_, extension()->id());
 
-  scoped_ptr<base::Value> result(
+  std::unique_ptr<base::Value> result(
       RunFunctionAndReturnValue(new IdleSetDetectionIntervalFunction(),
                                 "[18000]"));  // five hours in seconds
 
   idle_provider_->set_locked(false);
   idle_provider_->set_idle_time(4 * 60 * 60 - 1);
   idle_manager_->UpdateIdleState();
 
   idle_provider_->set_idle_time(4 * 60 * 60);
   EXPECT_CALL(*event_delegate_,
               OnStateChanged(extension()->id(), ui::IDLE_STATE_IDLE));
   idle_manager_->UpdateIdleState();
 }
 
 // Verifies that setting a detection interval below the minimum value results
 // in an interval of 15 seconds.
 TEST_F(IdleTest, SetDetectionIntervalMinimum) {
   ScopedListen listen_extension(idle_manager_, extension()->id());
 
-  scoped_ptr<base::Value> result(RunFunctionAndReturnValue(
+  std::unique_ptr<base::Value> result(RunFunctionAndReturnValue(
       new IdleSetDetectionIntervalFunction(), "[10]"));
 
   idle_provider_->set_locked(false);
   idle_provider_->set_idle_time(14);
   idle_manager_->UpdateIdleState();
 
   idle_provider_->set_idle_time(15);
   EXPECT_CALL(*event_delegate_,
               OnStateChanged(extension()->id(), ui::IDLE_STATE_IDLE));
   idle_manager_->UpdateIdleState();
 }
 
 // Verifies that an extension's detection interval is discarded when it unloads.
 TEST_F(IdleTest, UnloadCleanup) {
   {
     ScopedListen listen(idle_manager_, extension()->id());
 
-    scoped_ptr<base::Value> result45(RunFunctionAndReturnValue(
+    std::unique_ptr<base::Value> result45(RunFunctionAndReturnValue(
         new IdleSetDetectionIntervalFunction(), "[15]"));
   }
 
   // Listener count dropping to zero does not reset threshold.
 
   {
     ScopedListen listen(idle_manager_, extension()->id());
     idle_provider_->set_idle_time(16);
     EXPECT_CALL(*event_delegate_,
                 OnStateChanged(extension()->id(), ui::IDLE_STATE_IDLE));
@@ skipping 54 matching lines @@
 
   {
     // Nothing should have fired, the listener wasn't added until afterward.
     ScopedListen listen(idle_manager_, "test");
     idle_manager_->UpdateIdleState();
     testing::Mock::VerifyAndClearExpectations(event_delegate_);
   }
 }
 
 }  // namespace extensions