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

chrome/browser/extensions/user_script_listener_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 "chrome/browser/extensions/user_script_listener.h"
+
+#include <memory>
+
 #include "base/files/file_util.h"
 #include "base/json/json_file_value_serializer.h"
 #include "base/macros.h"
-#include "base/memory/scoped_ptr.h"
 #include "base/message_loop/message_loop.h"
 #include "base/threading/thread.h"
 #include "chrome/browser/chrome_notification_types.h"
 #include "chrome/browser/extensions/extension_service.h"
 #include "chrome/browser/extensions/extension_service_test_base.h"
 #include "chrome/browser/extensions/unpacked_installer.h"
-#include "chrome/browser/extensions/user_script_listener.h"
 #include "chrome/common/chrome_paths.h"
 #include "chrome/test/base/testing_profile.h"
 #include "content/public/browser/notification_service.h"
 #include "content/public/browser/resource_controller.h"
 #include "content/public/browser/resource_throttle.h"
 #include "extensions/browser/extension_registry.h"
 #include "net/base/request_priority.h"
 #include "net/url_request/url_request.h"
 #include "net/url_request/url_request_filter.h"
 #include "net/url_request/url_request_interceptor.h"
@@ skipping 23 matching lines @@
   }
 
   // ResourceController implementation:
   void Resume() override { request_->Start(); }
   void Cancel() override { NOTREACHED(); }
   void CancelAndIgnore() override { NOTREACHED(); }
   void CancelWithError(int error_code) override { NOTREACHED(); }
 
  private:
   net::URLRequest* request_;
-  scoped_ptr<ResourceThrottle> throttle_;
+  std::unique_ptr<ResourceThrottle> throttle_;
 };
 
 // A simple test net::URLRequestJob. We don't care what it does, only that
 // whether it starts and finishes.
 class SimpleTestJob : public net::URLRequestTestJob {
  public:
   SimpleTestJob(net::URLRequest* request,
                 net::NetworkDelegate* network_delegate)
       : net::URLRequestTestJob(request,
                                network_delegate,
                                test_headers(),
                                kTestData,
                                true) {}
  private:
   ~SimpleTestJob() override {}
 };
 
 // Yoinked from extension_manifest_unittest.cc.
-scoped_ptr<base::DictionaryValue> LoadManifestFile(const base::FilePath path,
-                                                   std::string* error) {
+std::unique_ptr<base::DictionaryValue> LoadManifestFile(
+    const base::FilePath path,
+    std::string* error) {
   EXPECT_TRUE(base::PathExists(path));
   JSONFileValueDeserializer deserializer(path);
   return base::DictionaryValue::From(deserializer.Deserialize(NULL, error));
 }
 
 scoped_refptr<Extension> LoadExtension(const std::string& filename,
                                        std::string* error) {
   base::FilePath path;
   PathService::Get(chrome::DIR_TEST_DATA, &path);
   path = path.
       AppendASCII("extensions").
       AppendASCII("manifest_tests").
       AppendASCII(filename.c_str());
-  scoped_ptr<base::DictionaryValue> value = LoadManifestFile(path, error);
+  std::unique_ptr<base::DictionaryValue> value = LoadManifestFile(path, error);
   if (!value)
     return NULL;
   return Extension::Create(path.DirName(), Manifest::UNPACKED, *value,
                            Extension::NO_FLAGS, error);
 }
 
 class SimpleTestJobURLRequestInterceptor
     : public net::URLRequestInterceptor {
  public:
   SimpleTestJobURLRequestInterceptor() {}
   ~SimpleTestJobURLRequestInterceptor() override {}
 
   // net::URLRequestJobFactory::ProtocolHandler
   net::URLRequestJob* MaybeInterceptRequest(
       net::URLRequest* request,
       net::NetworkDelegate* network_delegate) const override {
     return new SimpleTestJob(request, network_delegate);
   }
 
  private:
   DISALLOW_COPY_AND_ASSIGN(SimpleTestJobURLRequestInterceptor);
 };
 
 }  // namespace
 
 class UserScriptListenerTest : public ExtensionServiceTestBase {
  public:
   UserScriptListenerTest() {
     net::URLRequestFilter::GetInstance()->AddHostnameInterceptor(
-        "http", "google.com",
-        scoped_ptr<net::URLRequestInterceptor>(
-            new SimpleTestJobURLRequestInterceptor()));
+        "http", "google.com", std::unique_ptr<net::URLRequestInterceptor>(
+                                  new SimpleTestJobURLRequestInterceptor()));
     net::URLRequestFilter::GetInstance()->AddHostnameInterceptor(
-        "http", "example.com",
-        scoped_ptr<net::URLRequestInterceptor>(
-            new SimpleTestJobURLRequestInterceptor()));
+        "http", "example.com", std::unique_ptr<net::URLRequestInterceptor>(
+                                   new SimpleTestJobURLRequestInterceptor()));
   }
 
   ~UserScriptListenerTest() override {
     net::URLRequestFilter::GetInstance()->RemoveHostnameHandler("http",
                                                                 "google.com");
     net::URLRequestFilter::GetInstance()->RemoveHostnameHandler("http",
                                                                 "example.com");
   }
 
   void SetUp() override {
     ExtensionServiceTestBase::SetUp();
 
     InitializeEmptyExtensionService();
     service_->Init();
     base::MessageLoop::current()->RunUntilIdle();
 
     listener_ = new UserScriptListener();
   }
 
   void TearDown() override {
     listener_ = NULL;
     base::MessageLoop::current()->RunUntilIdle();
     ExtensionServiceTestBase::TearDown();
   }
 
  protected:
-  scoped_ptr<net::URLRequest> StartTestRequest(
+  std::unique_ptr<net::URLRequest> StartTestRequest(
       net::URLRequest::Delegate* delegate,
       const std::string& url_string,
       net::TestURLRequestContext* context) {
     GURL url(url_string);
-    scoped_ptr<net::URLRequest> request(context->CreateRequest(
-        url, net::DEFAULT_PRIORITY, delegate));
+    std::unique_ptr<net::URLRequest> request(
+        context->CreateRequest(url, net::DEFAULT_PRIORITY, delegate));
 
     ResourceThrottle* throttle = listener_->CreateResourceThrottle(
         url, content::RESOURCE_TYPE_MAIN_FRAME);
 
     bool defer = false;
     if (throttle) {
       request->SetUserData(NULL,
                            new ThrottleController(request.get(), throttle));
 
       throttle->WillStartRequest(&defer);
@@ skipping 29 matching lines @@
 };
 
 namespace {
 
 TEST_F(UserScriptListenerTest, DelayAndUpdate) {
   LoadTestExtension();
   base::MessageLoop::current()->RunUntilIdle();
 
   net::TestDelegate delegate;
   net::TestURLRequestContext context;
-  scoped_ptr<net::URLRequest> request(
+  std::unique_ptr<net::URLRequest> request(
       StartTestRequest(&delegate, kMatchingUrl, &context));
   ASSERT_FALSE(request->is_pending());
 
   content::NotificationService::current()->Notify(
       extensions::NOTIFICATION_USER_SCRIPTS_UPDATED,
       content::Source<Profile>(profile_.get()),
       content::NotificationService::NoDetails());
   base::MessageLoop::current()->RunUntilIdle();
   EXPECT_EQ(kTestData, delegate.data_received());
 }
 
 TEST_F(UserScriptListenerTest, DelayAndUnload) {
   LoadTestExtension();
   base::MessageLoop::current()->RunUntilIdle();
 
   net::TestDelegate delegate;
   net::TestURLRequestContext context;
-  scoped_ptr<net::URLRequest> request(
+  std::unique_ptr<net::URLRequest> request(
       StartTestRequest(&delegate, kMatchingUrl, &context));
   ASSERT_FALSE(request->is_pending());
 
   UnloadTestExtension();
   base::MessageLoop::current()->RunUntilIdle();
 
   // This is still not enough to start delayed requests. We have to notify the
   // listener that the user scripts have been updated.
   ASSERT_FALSE(request->is_pending());
 
   content::NotificationService::current()->Notify(
       extensions::NOTIFICATION_USER_SCRIPTS_UPDATED,
       content::Source<Profile>(profile_.get()),
       content::NotificationService::NoDetails());
   base::MessageLoop::current()->RunUntilIdle();
   EXPECT_EQ(kTestData, delegate.data_received());
 }
 
 TEST_F(UserScriptListenerTest, NoDelayNoExtension) {
   net::TestDelegate delegate;
   net::TestURLRequestContext context;
-  scoped_ptr<net::URLRequest> request(
+  std::unique_ptr<net::URLRequest> request(
       StartTestRequest(&delegate, kMatchingUrl, &context));
 
   // The request should be started immediately.
   ASSERT_TRUE(request->is_pending());
 
   base::MessageLoop::current()->RunUntilIdle();
   EXPECT_EQ(kTestData, delegate.data_received());
 }
 
 TEST_F(UserScriptListenerTest, NoDelayNotMatching) {
   LoadTestExtension();
   base::MessageLoop::current()->RunUntilIdle();
 
   net::TestDelegate delegate;
   net::TestURLRequestContext context;
-  scoped_ptr<net::URLRequest> request(
+  std::unique_ptr<net::URLRequest> request(
       StartTestRequest(&delegate, kNotMatchingUrl, &context));
 
   // The request should be started immediately.
   ASSERT_TRUE(request->is_pending());
 
   base::MessageLoop::current()->RunUntilIdle();
   EXPECT_EQ(kTestData, delegate.data_received());
 }
 
 TEST_F(UserScriptListenerTest, MultiProfile) {
@@ skipping 10 matching lines @@
 
   extensions::ExtensionRegistry::Get(&profile2)->AddEnabled(extension);
 
   content::NotificationService::current()->Notify(
       extensions::NOTIFICATION_EXTENSION_LOADED_DEPRECATED,
       content::Source<Profile>(&profile2),
       content::Details<Extension>(extension.get()));
 
   net::TestDelegate delegate;
   net::TestURLRequestContext context;
-  scoped_ptr<net::URLRequest> request(
+  std::unique_ptr<net::URLRequest> request(
       StartTestRequest(&delegate, kMatchingUrl, &context));
   ASSERT_FALSE(request->is_pending());
 
   // When the first profile's user scripts are ready, the request should still
   // be blocked waiting for profile2.
   content::NotificationService::current()->Notify(
       extensions::NOTIFICATION_USER_SCRIPTS_UPDATED,
       content::Source<Profile>(profile_.get()),
       content::NotificationService::NoDetails());
   base::MessageLoop::current()->RunUntilIdle();
@@ skipping 11 matching lines @@
 
 // Test when the script updated notification occurs before the throttle's
 // WillStartRequest function is called.  This can occur when there are multiple
 // throttles.
 TEST_F(UserScriptListenerTest, ResumeBeforeStart) {
   LoadTestExtension();
   base::MessageLoop::current()->RunUntilIdle();
   net::TestDelegate delegate;
   net::TestURLRequestContext context;
   GURL url(kMatchingUrl);
-  scoped_ptr<net::URLRequest> request(context.CreateRequest(
-      url, net::DEFAULT_PRIORITY, &delegate));
+  std::unique_ptr<net::URLRequest> request(
+      context.CreateRequest(url, net::DEFAULT_PRIORITY, &delegate));
 
   ResourceThrottle* throttle =
       listener_->CreateResourceThrottle(url, content::RESOURCE_TYPE_MAIN_FRAME);
   ASSERT_TRUE(throttle);
   request->SetUserData(NULL, new ThrottleController(request.get(), throttle));
 
   ASSERT_FALSE(request->is_pending());
 
   content::NotificationService::current()->Notify(
       extensions::NOTIFICATION_USER_SCRIPTS_UPDATED,
       content::Source<Profile>(profile_.get()),
       content::NotificationService::NoDetails());
   base::MessageLoop::current()->RunUntilIdle();
 
   bool defer = false;
   throttle->WillStartRequest(&defer);
   ASSERT_FALSE(defer);
 }
 
 }  // namespace
 
 }  // namespace extensions