Convert //content/renderer from scoped_ptr to std::unique_ptr

content/renderer/resource_fetcher_browsertest.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 "content/public/renderer/resource_fetcher.h"
 
 #include <stdint.h>
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/command_line.h"
@@ skipping 106 matching lines @@
     FetcherDelegate::OnURLFetchComplete(response, data);
 
     // Destroy the ResourceFetcher here.  We are testing that upon returning
     // to the ResourceFetcher that it does not crash.  This must be done after
     // calling FetcherDelegate::OnURLFetchComplete, since deleting the fetcher
     // invalidates |response| and |data|.
     fetcher_.reset();
   }
 
  private:
-  scoped_ptr<ResourceFetcher> fetcher_;
+  std::unique_ptr<ResourceFetcher> fetcher_;
 };
 
 class ResourceFetcherTests : public ContentBrowserTest {
  public:
   ResourceFetcherTests() : render_view_routing_id_(MSG_ROUTING_NONE) {}
 
   void SetUpCommandLine(base::CommandLine* command_line) override {
     command_line->AppendSwitch(switches::kSingleProcess);
 #if defined(OS_WIN)
     // Don't want to try to create a GPU process.
     command_line->AppendSwitch(switches::kDisableGpu);
 #endif
   }
 
   void SetUpOnMainThread() override {
     render_view_routing_id_ =
         shell()->web_contents()->GetRenderViewHost()->GetRoutingID();
   }
 
   RenderView* GetRenderView() {
     return RenderView::FromRoutingID(render_view_routing_id_);
   }
 
   void ResourceFetcherDownloadOnRenderer(const GURL& url) {
     WebFrame* frame = GetRenderView()->GetWebView()->mainFrame();
 
-    scoped_ptr<FetcherDelegate> delegate(new FetcherDelegate);
-    scoped_ptr<ResourceFetcher> fetcher(ResourceFetcher::Create(url));
+    std::unique_ptr<FetcherDelegate> delegate(new FetcherDelegate);
+    std::unique_ptr<ResourceFetcher> fetcher(ResourceFetcher::Create(url));
     fetcher->Start(frame,
                    WebURLRequest::RequestContextInternal,
                    WebURLRequest::FrameTypeNone,
                    ResourceFetcher::PLATFORM_LOADER,
                    delegate->NewCallback());
 
     delegate->WaitForResponse();
 
     ASSERT_TRUE(delegate->completed());
     EXPECT_EQ(delegate->response().httpStatusCode(), 200);
     std::string text = delegate->data();
     EXPECT_TRUE(text.find("Basic html test.") != std::string::npos);
   }
 
   void ResourceFetcher404OnRenderer(const GURL& url) {
     WebFrame* frame = GetRenderView()->GetWebView()->mainFrame();
 
-    scoped_ptr<FetcherDelegate> delegate(new FetcherDelegate);
-    scoped_ptr<ResourceFetcher> fetcher(ResourceFetcher::Create(url));
+    std::unique_ptr<FetcherDelegate> delegate(new FetcherDelegate);
+    std::unique_ptr<ResourceFetcher> fetcher(ResourceFetcher::Create(url));
     fetcher->Start(frame,
                    WebURLRequest::RequestContextInternal,
                    WebURLRequest::FrameTypeNone,
                    ResourceFetcher::PLATFORM_LOADER,
                    delegate->NewCallback());
 
     delegate->WaitForResponse();
 
     ASSERT_TRUE(delegate->completed());
     EXPECT_EQ(delegate->response().httpStatusCode(), 404);
   }
 
   void ResourceFetcherDidFailOnRenderer() {
     WebFrame* frame = GetRenderView()->GetWebView()->mainFrame();
 
     // Try to fetch a page on a site that doesn't exist.
     GURL url("http://localhost:1339/doesnotexist");
-    scoped_ptr<FetcherDelegate> delegate(new FetcherDelegate);
-    scoped_ptr<ResourceFetcher> fetcher(ResourceFetcher::Create(url));
+    std::unique_ptr<FetcherDelegate> delegate(new FetcherDelegate);
+    std::unique_ptr<ResourceFetcher> fetcher(ResourceFetcher::Create(url));
     fetcher->Start(frame,
                    WebURLRequest::RequestContextInternal,
                    WebURLRequest::FrameTypeNone,
                    ResourceFetcher::PLATFORM_LOADER,
                    delegate->NewCallback());
 
     delegate->WaitForResponse();
 
     // When we fail, we still call the Delegate callback but we pass in empty
     // values.
     EXPECT_TRUE(delegate->completed());
     EXPECT_TRUE(delegate->response().isNull());
     EXPECT_EQ(delegate->data(), std::string());
     EXPECT_FALSE(delegate->timed_out());
   }
 
   void ResourceFetcherTimeoutOnRenderer(const GURL& url) {
     WebFrame* frame = GetRenderView()->GetWebView()->mainFrame();
 
-    scoped_ptr<FetcherDelegate> delegate(new FetcherDelegate);
-    scoped_ptr<ResourceFetcher> fetcher(ResourceFetcher::Create(url));
+    std::unique_ptr<FetcherDelegate> delegate(new FetcherDelegate);
+    std::unique_ptr<ResourceFetcher> fetcher(ResourceFetcher::Create(url));
     fetcher->Start(frame,
                    WebURLRequest::RequestContextInternal,
                    WebURLRequest::FrameTypeNone,
                    ResourceFetcher::PLATFORM_LOADER,
                    delegate->NewCallback());
     fetcher->SetTimeout(base::TimeDelta());
 
     delegate->WaitForResponse();
 
     // When we timeout, we still call the Delegate callback but we pass in empty
     // values.
     EXPECT_TRUE(delegate->completed());
     EXPECT_TRUE(delegate->response().isNull());
     EXPECT_EQ(delegate->data(), std::string());
     EXPECT_FALSE(delegate->timed_out());
   }
 
   void ResourceFetcherDeletedInCallbackOnRenderer(const GURL& url) {
     WebFrame* frame = GetRenderView()->GetWebView()->mainFrame();
 
-    scoped_ptr<EvilFetcherDelegate> delegate(new EvilFetcherDelegate);
-    scoped_ptr<ResourceFetcher> fetcher(ResourceFetcher::Create(url));
+    std::unique_ptr<EvilFetcherDelegate> delegate(new EvilFetcherDelegate);
+    std::unique_ptr<ResourceFetcher> fetcher(ResourceFetcher::Create(url));
     fetcher->Start(frame,
                    WebURLRequest::RequestContextInternal,
                    WebURLRequest::FrameTypeNone,
                    ResourceFetcher::PLATFORM_LOADER,
                    delegate->NewCallback());
     fetcher->SetTimeout(base::TimeDelta());
     delegate->SetFetcher(fetcher.release());
 
     delegate->WaitForResponse();
     EXPECT_FALSE(delegate->timed_out());
   }
 
   void ResourceFetcherPost(const GURL& url) {
     const char* kBody = "Really nifty POST body!";
 
     WebFrame* frame = GetRenderView()->GetWebView()->mainFrame();
 
-    scoped_ptr<FetcherDelegate> delegate(new FetcherDelegate);
-    scoped_ptr<ResourceFetcher> fetcher(ResourceFetcher::Create(url));
+    std::unique_ptr<FetcherDelegate> delegate(new FetcherDelegate);
+    std::unique_ptr<ResourceFetcher> fetcher(ResourceFetcher::Create(url));
     fetcher->SetMethod("POST");
     fetcher->SetBody(kBody);
     fetcher->Start(frame,
                    WebURLRequest::RequestContextInternal,
                    WebURLRequest::FrameTypeNone,
                    ResourceFetcher::PLATFORM_LOADER,
                    delegate->NewCallback());
 
     delegate->WaitForResponse();
     ASSERT_TRUE(delegate->completed());
     EXPECT_EQ(delegate->response().httpStatusCode(), 200);
     EXPECT_EQ(kBody, delegate->data());
   }
 
   void ResourceFetcherSetHeader(const GURL& url) {
     const char* kHeader = "Rather boring header.";
 
     WebFrame* frame = GetRenderView()->GetWebView()->mainFrame();
 
-    scoped_ptr<FetcherDelegate> delegate(new FetcherDelegate);
-    scoped_ptr<ResourceFetcher> fetcher(ResourceFetcher::Create(url));
+    std::unique_ptr<FetcherDelegate> delegate(new FetcherDelegate);
+    std::unique_ptr<ResourceFetcher> fetcher(ResourceFetcher::Create(url));
     fetcher->SetHeader("header", kHeader);
     fetcher->Start(frame,
                    WebURLRequest::RequestContextInternal,
                    WebURLRequest::FrameTypeNone,
                    ResourceFetcher::PLATFORM_LOADER,
                    delegate->NewCallback());
 
     delegate->WaitForResponse();
     ASSERT_TRUE(delegate->completed());
     EXPECT_EQ(delegate->response().httpStatusCode(), 200);
@@ skipping 95 matching lines @@
   ASSERT_TRUE(embedded_test_server()->Start());
   GURL url(embedded_test_server()->GetURL("/echoheader?header"));
 
   PostTaskToInProcessRendererAndWait(
         base::Bind(
             &ResourceFetcherTests::ResourceFetcherSetHeader,
             base::Unretained(this), url));
 }
 
 }  // namespace content