Deprecate RegisterProtocolFactory/(Un)RegisterInterceptor.

webkit/fileapi/file_system_url_request_job_unittest.cc

 // Copyright (c) 2011 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.
 //
 // NOTE: These tests are run as part of "unit_tests" (in chrome/test/unit)
 // rather than as part of test_shell_tests because they rely on being able
 // to instantiate a MessageLoop of type TYPE_IO.  test_shell_tests uses
 // TYPE_UI, which URLRequest doesn't allow.
 //
 
@@ skipping 57 matching lines @@
 
   virtual bool IsStorageUnlimited(const GURL& origin) {
     return true;
   }
 
   virtual bool IsFileHandler(const std::string& extension_id) {
     return true;
   }
 };
 
+}  // namespace
+
 class FileSystemURLRequestJobTest : public testing::Test {
  protected:
   FileSystemURLRequestJobTest()
     : message_loop_(MessageLoop::TYPE_IO),  // simulate an IO thread
       ALLOW_THIS_IN_INITIALIZER_LIST(callback_factory_(this)) {
   }
 
   virtual void SetUp() {
     ASSERT_TRUE(temp_dir_.CreateUniqueTempDir());
 
@@ skipping 10 matching lines @@
             new FileSystemPathManager(
                 base::MessageLoopProxy::CreateForCurrentThread(),
                 temp_dir_.path(), NULL, false, false));
 
     file_system_context_->path_manager()->ValidateFileSystemRootAndGetURL(
         GURL("http://remote/"), kFileSystemTypeTemporary, true,  // create
         callback_factory_.NewCallback(
             &FileSystemURLRequestJobTest::OnGetRootPath));
     MessageLoop::current()->RunAllPending();
 
-    net::URLRequest::RegisterProtocolFactory("filesystem",
-                                             &FileSystemURLRequestJobFactory);
+    net::URLRequest::Deprecated::RegisterProtocolFactory(
+        "filesystem", &FileSystemURLRequestJobFactory);
   }
 
   virtual void TearDown() {
-    net::URLRequest::RegisterProtocolFactory("filesystem", NULL);
+    net::URLRequest::Deprecated::RegisterProtocolFactory("filesystem", NULL);
   }
 
   void OnGetRootPath(bool success, const FilePath& root_path,
                      const std::string& name) {
     ASSERT_TRUE(success);
     origin_root_path_ = root_path;
   }
 
   void TestRequestHelper(const GURL& url,
                          const net::HttpRequestHeaders* headers,
@@ skipping 97 matching lines @@
   // NOTE: order matters, request must die before delegate
   scoped_ptr<TestDelegate> delegate_;
   scoped_ptr<net::URLRequest> request_;
 
   static net::URLRequestJob* job_;
 };
 
 // static
 net::URLRequestJob* FileSystemURLRequestJobTest::job_ = NULL;
 
+namespace {
+
 TEST_F(FileSystemURLRequestJobTest, FileTest) {
   WriteFile("file1.dat", kTestFileData, arraysize(kTestFileData) - 1);
   TestRequest(CreateFileSystemURL("file1.dat"));
 
   ASSERT_FALSE(request_->is_pending());
   EXPECT_EQ(1, delegate_->response_started_count());
   EXPECT_FALSE(delegate_->received_data_before_response());
   EXPECT_EQ(kTestFileData, delegate_->data_received());
   EXPECT_EQ(200, request_->GetResponseCode());
   std::string cache_control;
@@ skipping 138 matching lines @@
 
   TestRequest(CreateFileSystemURL(kFilename));
 
   std::string mime_type_from_job;
   request_->GetMimeType(&mime_type_from_job);
   EXPECT_EQ(mime_type_direct, mime_type_from_job);
 }
 
 }  // namespace (anonymous)
 }  // namespace fileapi