Remove ProtocolFactory use from file_writer_delegate_unittest

content/browser/fileapi/file_writer_delegate_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 <string>
 #include <vector>
 
 #include "base/basictypes.h"
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/files/scoped_temp_dir.h"
 #include "base/message_loop/message_loop.h"
 #include "base/run_loop.h"
 #include "content/public/test/async_file_test_helper.h"
 #include "content/public/test/test_file_system_context.h"
 #include "net/base/io_buffer.h"
 #include "net/base/request_priority.h"
 #include "net/url_request/url_request.h"
 #include "net/url_request/url_request_context.h"
 #include "net/url_request/url_request_job.h"
+#include "net/url_request/url_request_job_factory.h"
 #include "net/url_request/url_request_status.h"
 #include "testing/platform_test.h"
 #include "url/gurl.h"
 #include "webkit/browser/fileapi/file_system_context.h"
 #include "webkit/browser/fileapi/file_system_quota_util.h"
 #include "webkit/browser/fileapi/file_writer_delegate.h"
 #include "webkit/browser/fileapi/sandbox_file_stream_writer.h"
 
 using content::AsyncFileTestHelper;
 using fileapi::FileSystemURL;
@@ skipping 36 matching lines @@
     }
   }
 
  private:
   // For post-operation status.
   base::File::Error status_;
   int64 bytes_written_;
   FileWriterDelegate::WriteProgressStatus write_status_;
 };
 
+class BlobURLRequestJobFactory;
+
 }  // namespace (anonymous)
 
 class FileWriterDelegateTest : public PlatformTest {
  public:
   FileWriterDelegateTest() {}
 
  protected:
   virtual void SetUp() OVERRIDE;
   virtual void TearDown() OVERRIDE;
 
@@ skipping 47 matching lines @@
   void PrepareForWrite(const char* test_file_path,
                        const GURL& blob_url,
                        int64 offset,
                        int64 allowed_growth) {
     file_writer_delegate_.reset(
         CreateWriterDelegate(test_file_path, offset, allowed_growth));
     request_ = empty_context_.CreateRequest(
         blob_url, net::DEFAULT_PRIORITY, file_writer_delegate_.get(), NULL);
   }
 
-  static net::URLRequest::ProtocolFactory Factory;
-
   // This should be alive until the very end of this instance.
   base::MessageLoopForIO loop_;
 
   scoped_refptr<fileapi::FileSystemContext> file_system_context_;
 
   net::URLRequestContext empty_context_;
   scoped_ptr<FileWriterDelegate> file_writer_delegate_;
   scoped_ptr<net::URLRequest> request_;
+  scoped_ptr<BlobURLRequestJobFactory> job_factory_;
 
   base::ScopedTempDir dir_;
 
   static const char* content_;
 };
 
 const char* FileWriterDelegateTest::content_ = NULL;
 
 namespace {
 
@@ skipping 37 matching lines @@
 
  protected:
   virtual ~FileWriterDelegateTestJob() {}
 
  private:
   std::string content_;
   int remaining_bytes_;
   int cursor_;
 };
 
+class BlobURLRequestJobFactory : public net::URLRequestJobFactory {
+ public:
+  explicit BlobURLRequestJobFactory(const char** content_data)
+      : content_data_(content_data) {
+  }
+
+  virtual net::URLRequestJob* MaybeCreateJobWithProtocolHandler(
+      const std::string& scheme,
+      net::URLRequest* request,
+      net::NetworkDelegate* network_delegate) const OVERRIDE {
+    return new FileWriterDelegateTestJob(
+        request, network_delegate, *content_data_);
+  }
+
+  virtual bool IsHandledProtocol(const std::string& scheme) const OVERRIDE {
+    return scheme == "blob";
+  }
+
+  virtual bool IsHandledURL(const GURL& url) const OVERRIDE {
+    return url.SchemeIs("blob");
+  }
+
+  virtual bool IsSafeRedirectTarget(const GURL& location) const OVERRIDE {
+    return true;
+  }
+
+ private:
+  const char** content_data_;
+
+  DISALLOW_COPY_AND_ASSIGN(BlobURLRequestJobFactory);
+};
+
 }  // namespace (anonymous)
 
-// static
-net::URLRequestJob* FileWriterDelegateTest::Factory(
-    net::URLRequest* request,
-    net::NetworkDelegate* network_delegate,
-    const std::string& scheme) {
-  return new FileWriterDelegateTestJob(
-      request, network_delegate, FileWriterDelegateTest::content_);
-}
-
 void FileWriterDelegateTest::SetUp() {
   ASSERT_TRUE(dir_.CreateUniqueTempDir());
 
   file_system_context_ = CreateFileSystemContextForTesting(
       NULL, dir_.path());
   ASSERT_EQ(base::File::FILE_OK,
             AsyncFileTestHelper::CreateFile(
                 file_system_context_, GetFileSystemURL("test")));
-  net::URLRequest::Deprecated::RegisterProtocolFactory("blob", &Factory);
+  job_factory_.reset(new BlobURLRequestJobFactory(&content_));
+  empty_context_.set_job_factory(job_factory_.get());
 }
 
 void FileWriterDelegateTest::TearDown() {
-  net::URLRequest::Deprecated::RegisterProtocolFactory("blob", NULL);
   file_system_context_ = NULL;
   base::RunLoop().RunUntilIdle();
 }
 
 TEST_F(FileWriterDelegateTest, WriteSuccessWithoutQuotaLimit) {
   const GURL kBlobURL("blob:nolimit");
   content_ = kData;
 
   PrepareForWrite("test", kBlobURL, 0, kint64max);
 
@@ skipping 208 matching lines @@
     file_writer_delegate_.reset();
 
     EXPECT_EQ(pre_write_usage + allowed_growth, usage());
     EXPECT_EQ(GetFileSizeOnDisk("test"), usage());
     EXPECT_EQ(kOverlap + allowed_growth, result.bytes_written());
     EXPECT_EQ(base::File::FILE_ERROR_NO_SPACE, result.status());
   }
 }
 
 }  // namespace content