Remove URLRequest::Restart() because it is only referenced by unit tests

net/url_request/url_request_unittest.cc

 // Copyright (c) 2006-2009 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 "net/url_request/url_request_unittest.h"
 
 #include "build/build_config.h"
 
 #if defined(OS_WIN)
 #include <windows.h>
@@ skipping 1343 matching lines @@
   req.set_upload(CreateSimpleUploadData(kData).get());
   req.SetExtraRequestHeaders(
       "Content-Length: " + UintToString(sizeof(kData) - 1));
   req.Start();
   MessageLoop::current()->Run();
   EXPECT_EQ("POST", req.method());
   EXPECT_EQ(kData, d.data_received());
 }
 
 // Custom URLRequestJobs for use with interceptor tests
-class RestartTestJob : public URLRequestTestJob {
- public:
-  explicit RestartTestJob(URLRequest* request)
-    : URLRequestTestJob(request, true) {}
- protected:
-  virtual void StartAsync() {
-    this->NotifyRestartRequired();
-  }
-};
-
 class CancelTestJob : public URLRequestTestJob {
  public:
   explicit CancelTestJob(URLRequest* request)
     : URLRequestTestJob(request, true) {}
  protected:
   virtual void StartAsync() {
     request_->Cancel();
   }
 };
 
-class CancelThenRestartTestJob : public URLRequestTestJob {
- public:
-  explicit CancelThenRestartTestJob(URLRequest* request)
-      : URLRequestTestJob(request, true) {
-  }
- protected:
-  virtual void StartAsync() {
-    request_->Cancel();
-    this->NotifyRestartRequired();
-  }
-};
-
 // An Interceptor for use with interceptor tests
 class TestInterceptor : URLRequest::Interceptor {
  public:
   TestInterceptor()
-      : intercept_main_request_(false), restart_main_request_(false),
-        cancel_main_request_(false), cancel_then_restart_main_request_(false),
+      : intercept_main_request_(false), cancel_main_request_(false),
         simulate_main_network_error_(false),
         intercept_redirect_(false), cancel_redirect_request_(false),
         intercept_final_response_(false), cancel_final_request_(false),
-        did_intercept_main_(false), did_restart_main_(false),
-        did_cancel_main_(false), did_cancel_then_restart_main_(false),
+        did_intercept_main_(false), did_cancel_main_(false),
         did_simulate_error_main_(false),
         did_intercept_redirect_(false), did_cancel_redirect_(false),
         did_intercept_final_(false), did_cancel_final_(false) {
     URLRequest::RegisterRequestInterceptor(this);
   }
 
   ~TestInterceptor() {
     URLRequest::UnregisterRequestInterceptor(this);
   }
 
   virtual URLRequestJob* MaybeIntercept(URLRequest* request) {
-    if (restart_main_request_) {
-      restart_main_request_ = false;
-      did_restart_main_ = true;
-      return new RestartTestJob(request);
-    }
     if (cancel_main_request_) {
       cancel_main_request_ = false;
       did_cancel_main_ = true;
       return new CancelTestJob(request);
     }
-    if (cancel_then_restart_main_request_) {
-      cancel_then_restart_main_request_ = false;
-      did_cancel_then_restart_main_ = true;
-      return new CancelThenRestartTestJob(request);
-    }
     if (simulate_main_network_error_) {
       simulate_main_network_error_ = false;
       did_simulate_error_main_ = true;
       // will error since the requeted url is not one of its canned urls
       return new URLRequestTestJob(request, true);
     }
     if (!intercept_main_request_)
       return NULL;
     intercept_main_request_ = false;
     did_intercept_main_ = true;
@@ skipping 35 matching lines @@
                                  final_data_,
                                  true);
   }
 
   // Whether to intercept the main request, and if so the response to return.
   bool intercept_main_request_;
   std::string main_headers_;
   std::string main_data_;
 
   // Other actions we take at MaybeIntercept time
-  bool restart_main_request_;
   bool cancel_main_request_;
-  bool cancel_then_restart_main_request_;
   bool simulate_main_network_error_;
 
   // Whether to intercept redirects, and if so the response to return.
   bool intercept_redirect_;
   std::string redirect_headers_;
   std::string redirect_data_;
 
   // Other actions we can take at MaybeInterceptRedirect time
   bool cancel_redirect_request_;
 
   // Whether to intercept final response, and if so the response to return.
   bool intercept_final_response_;
   std::string final_headers_;
   std::string final_data_;
 
   // Other actions we can take at MaybeInterceptResponse time
   bool cancel_final_request_;
 
   // If we did something or not
   bool did_intercept_main_;
-  bool did_restart_main_;
   bool did_cancel_main_;
-  bool did_cancel_then_restart_main_;
   bool did_simulate_error_main_;
   bool did_intercept_redirect_;
   bool did_cancel_redirect_;
   bool did_intercept_final_;
   bool did_cancel_final_;
 
   // Static getters for canned response header and data strings
 
   static std::string ok_data() {
     return URLRequestTestJob::test_data_1();
@@ skipping 140 matching lines @@
   EXPECT_TRUE(interceptor.did_intercept_final_);
 
   // Check we received one good response
   EXPECT_TRUE(req.status().is_success());
   EXPECT_EQ(200, req.response_headers()->response_code());
   EXPECT_EQ(TestInterceptor::ok_data(), d.data_received());
   EXPECT_EQ(1, d.response_started_count());
   EXPECT_EQ(0, d.received_redirect_count());
 }
 
-TEST_F(URLRequestTest, InterceptRestartRequired) {
-  TestInterceptor interceptor;
-
-  // restart the main request
-  interceptor.restart_main_request_ = true;
-
-  // then intercept the new main request and respond with an OK response
-  interceptor.intercept_main_request_ = true;
-  interceptor.main_headers_ = TestInterceptor::ok_headers();
-  interceptor.main_data_ = TestInterceptor::ok_data();
-
-  TestDelegate d;
-  TestURLRequest req(GURL("http://test_intercept/foo"), &d);
-  req.set_method("GET");
-  req.Start();
-  MessageLoop::current()->Run();
-
-  // Check the interceptor got called as expected
-  EXPECT_TRUE(interceptor.did_restart_main_);
-  EXPECT_TRUE(interceptor.did_intercept_main_);
-
-  // Check we received one good response
-  EXPECT_TRUE(req.status().is_success());
-  EXPECT_EQ(200, req.response_headers()->response_code());
-  EXPECT_EQ(TestInterceptor::ok_data(), d.data_received());
-  EXPECT_EQ(1, d.response_started_count());
-  EXPECT_EQ(0, d.received_redirect_count());
-}
-
 TEST_F(URLRequestTest, InterceptRespectsCancelMain) {
   TestInterceptor interceptor;
 
   // intercept the main request and cancel from within the restarted job
   interceptor.cancel_main_request_ = true;
 
   // setup to intercept final response and override it with an OK response
   interceptor.intercept_final_response_ = true;
   interceptor.final_headers_ = TestInterceptor::ok_headers();
   interceptor.final_data_ = TestInterceptor::ok_data();
@@ skipping 62 matching lines @@
 
   // Check the interceptor got called as expected
   EXPECT_TRUE(interceptor.did_simulate_error_main_);
   EXPECT_TRUE(interceptor.did_cancel_final_);
 
   // Check we see a canceled request
   EXPECT_FALSE(req.status().is_success());
   EXPECT_EQ(URLRequestStatus::CANCELED, req.status().status());
 }
 
-TEST_F(URLRequestTest, InterceptRespectsCancelInRestart) {
-  TestInterceptor interceptor;
-
-  // intercept the main request and cancel then restart from within that job
-  interceptor.cancel_then_restart_main_request_ = true;
-
-  // setup to intercept final response and override it with an OK response
-  interceptor.intercept_final_response_ = true;
-  interceptor.final_headers_ = TestInterceptor::ok_headers();
-  interceptor.final_data_ = TestInterceptor::ok_data();
-
-  TestDelegate d;
-  TestURLRequest req(GURL("http://test_intercept/foo"), &d);
-  req.set_method("GET");
-  req.Start();
-  MessageLoop::current()->Run();
-
-  // Check the interceptor got called as expected
-  EXPECT_TRUE(interceptor.did_cancel_then_restart_main_);
-  EXPECT_FALSE(interceptor.did_intercept_final_);
-
-  // Check we see a canceled request
-  EXPECT_FALSE(req.status().is_success());
-  EXPECT_EQ(URLRequestStatus::CANCELED, req.status().status());
-}
-
 TEST_F(URLRequestTest, FTPGetTestAnonymous) {
   scoped_refptr<FTPTestServer> server = FTPTestServer::CreateServer(L"");
   ASSERT_TRUE(NULL != server.get());
   FilePath app_path;
   PathService::Get(base::DIR_SOURCE_ROOT, &app_path);
   app_path = app_path.AppendASCII("LICENSE");
   TestDelegate d;
   {
     TestURLRequest r(server->TestServerPage("/LICENSE"), &d);
     r.Start();
@@ skipping 78 matching lines @@
 
     int64 file_size = 0;
     file_util::GetFileSize(app_path, &file_size);
 
     EXPECT_FALSE(r.is_pending());
     EXPECT_EQ(1, d.response_started_count());
     EXPECT_FALSE(d.received_data_before_response());
     EXPECT_EQ(d.bytes_received(), 0);
   }
 }