Adjust URLFetcher::Create API so that object is returned as scoped_ptr.

extensions/browser/updater/update_service_browsertest.cc

 // Copyright 2014 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 <map>
 #include <string>
 #include <utility>
 
 #include "base/bind.h"
 #include "base/run_loop.h"
@@ skipping 87 matching lines @@
  public:
   ~FakeUpdateURLFetcherFactory() override {}
 
   void RegisterFakeExtension(const std::string& id,
                              const std::string& contents) {
     CHECK_EQ(32u, id.size());
     fake_extensions_.insert(std::make_pair(id, contents));
   }
 
   // net::URLFetcherFactory:
-  net::URLFetcher* CreateURLFetcher(
+  scoped_ptr<net::URLFetcher> CreateURLFetcher(
       int id,
       const GURL& url,
       net::URLFetcher::RequestType request_type,
       net::URLFetcherDelegate* delegate) override {
     if (url.spec().find(extension_urls::GetWebstoreUpdateUrl().spec()) == 0) {
       // Handle fake Omaha requests.
       return CreateUpdateManifestFetcher(url, delegate);
     } else if (url.spec().find("https://fake-omaha-hostname") == 0) {
       // Handle a fake CRX request.
       return CreateCrxFetcher(url, delegate);
     }
     NOTREACHED();
     return nullptr;
   }
 
  private:
-  net::URLFetcher* CreateUpdateManifestFetcher(
+  scoped_ptr<net::URLFetcher> CreateUpdateManifestFetcher(
       const GURL& url,
       net::URLFetcherDelegate* delegate) {
     // If we have a fake CRX for the ID, return a fake update blob for it.
     // Otherwise return an invalid-ID response.
     FakeResponse response;
     std::string extension_id;
     if (!ExtractIdFromUpdateQuery(url.query(), &extension_id)) {
       response = CreateFakeUpdateNotFoundResponse();
     } else {
       const auto& iter = fake_extensions_.find(extension_id);
       if (iter == fake_extensions_.end())
         response = CreateFakeUpdateNotFoundResponse();
       else
         response = CreateFakeUpdateResponse(extension_id, iter->second.size());
     }
-    return new net::FakeURLFetcher(url, delegate, response.first,
-                                   response.second,
-                                   net::URLRequestStatus::SUCCESS);
+    return scoped_ptr<net::URLFetcher>(
+        new net::FakeURLFetcher(url, delegate, response.first, response.second,
+                                net::URLRequestStatus::SUCCESS));
   }
 
-  net::URLFetcher* CreateCrxFetcher(const GURL& url,
-                                    net::URLFetcherDelegate* delegate) {
+  scoped_ptr<net::URLFetcher> CreateCrxFetcher(
+      const GURL& url,
+      net::URLFetcherDelegate* delegate) {
     FakeResponse response;
     std::string extension_id = url.path().substr(1, 32);
     const auto& iter = fake_extensions_.find(extension_id);
     if (iter == fake_extensions_.end())
       response = std::make_pair(std::string(), net::HTTP_NOT_FOUND);
     else
       response = std::make_pair(iter->second, net::HTTP_OK);
     net::TestURLFetcher* fetcher =
         new net::FakeURLFetcher(url, delegate, response.first, response.second,
                                 net::URLRequestStatus::SUCCESS);
     fetcher->SetResponseFilePath(base::FilePath::FromUTF8Unsafe(url.path()));
-    return fetcher;
+    return scoped_ptr<net::URLFetcher>(fetcher);
   }
 
   std::map<std::string, std::string> fake_extensions_;
 };
 
 }  // namespace
 
 class UpdateServiceTest : public AppShellTest {
  public:
   UpdateServiceTest() {}
@@ skipping 29 matching lines @@
   const char kCrxContents[] = "Hello, world!";
   RegisterFakeExtension(kCrxId, kCrxContents);
 
   base::RunLoop run_loop;
   update_service()->DownloadAndInstall(
       kCrxId, base::Bind(ExpectDownloadSuccess, run_loop.QuitClosure()));
   run_loop.Run();
 }
 
 }  // namespace extensions