moved upload progress logic from ResourceLoader to AsyncResourceHandler

content/browser/loader/resource_loader_unittest.cc

 // Copyright (c) 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 "content/browser/loader/resource_loader.h"
 
 #include "base/files/file.h"
 #include "base/files/file_util.h"
 #include "base/location.h"
 #include "base/macros.h"
@@ skipping 237 matching lines @@
       : ResourceHandler(request),
         read_buffer_(new net::IOBuffer(kReadBufSize)),
         defer_request_on_will_start_(false),
         expect_reads_(true),
         cancel_on_read_completed_(false),
         defer_eof_(false),
         received_on_will_read_(false),
         received_eof_(false),
         received_response_completed_(false),
         received_request_redirected_(false),
-        total_bytes_downloaded_(0),
-        upload_position_(0) {}
+        total_bytes_downloaded_(0) {}
 
   // If true, defers the resource load in OnWillStart.
   void set_defer_request_on_will_start(bool defer_request_on_will_start) {
     defer_request_on_will_start_ = defer_request_on_will_start;
   }
 
   // If true, expect OnWillRead / OnReadCompleted pairs for handling
   // data. Otherwise, expect OnDataDownloaded.
   void set_expect_reads(bool expect_reads) { expect_reads_ = expect_reads; }
 
@@ skipping 16 matching lines @@
   bool received_request_redirected() const {
     return received_request_redirected_;
   }
   const net::URLRequestStatus& status() const { return status_; }
   int total_bytes_downloaded() const { return total_bytes_downloaded_; }
 
   void Resume() {
     controller()->Resume();
   }
 
-  // Waits until OnUploadProgress is called and returns the upload position.
-  uint64 WaitForUploadProgress() {
-    wait_for_progress_loop_.reset(new base::RunLoop());
-    wait_for_progress_loop_->Run();
-    wait_for_progress_loop_.reset();
-    return upload_position_;
-  }
-
-  // ResourceHandler implementation:
-  bool OnUploadProgress(uint64 position, uint64 size) override {
-    EXPECT_LE(position, size);
-    EXPECT_GT(position, upload_position_);
-    upload_position_ = position;
-    if (wait_for_progress_loop_)
-      wait_for_progress_loop_->Quit();
-    return true;
-  }
-
   bool OnRequestRedirected(const net::RedirectInfo& redirect_info,
                            ResourceResponse* response,
                            bool* defer) override {
     redirect_response_ = response;
     received_request_redirected_ = true;
     return true;
   }
 
   bool OnResponseStarted(ResourceResponse* response, bool* defer) override {
     EXPECT_FALSE(response_.get());
@@ skipping 72 matching lines @@
   GURL start_url_;
   scoped_refptr<ResourceResponse> response_;
   scoped_refptr<ResourceResponse> redirect_response_;
   bool received_on_will_read_;
   bool received_eof_;
   bool received_response_completed_;
   bool received_request_redirected_;
   net::URLRequestStatus status_;
   int total_bytes_downloaded_;
   scoped_ptr<base::RunLoop> wait_for_progress_loop_;
-  uint64 upload_position_;
 };
 
 // Test browser client that captures calls to SelectClientCertificates and
 // records the arguments of the most recent call for later inspection.
 class SelectCertificateBrowserClient : public TestContentBrowserClient {
  public:
   SelectCertificateBrowserClient() : call_count_(0) {}
 
   void SelectClientCertificate(
       WebContents* web_contents,
@@ skipping 92 matching lines @@
       raw_ptr_to_request_(NULL) {
     test_url_request_context_.set_job_factory(&job_factory_);
   }
 
   GURL test_url() const { return net::URLRequestTestJob::test_url_1(); }
 
   std::string test_data() const {
     return net::URLRequestTestJob::test_data_1();
   }
 
-  // Waits until upload progress reaches |target_position|
-  void WaitForUploadProgress(uint64 target_position) {
-    while (true) {
-      uint64 position = raw_ptr_resource_handler_->WaitForUploadProgress();
-      EXPECT_LE(position, target_position);
-      loader_->OnUploadProgressACK();
-      if (position == target_position)
-        break;
-    }
-  }
-
   virtual net::URLRequestJobFactory::ProtocolHandler* CreateProtocolHandler() {
     return net::URLRequestTestJob::CreateProtocolHandler();
   }
 
   virtual scoped_ptr<ResourceHandler> WrapResourceHandler(
       scoped_ptr<ResourceHandlerStub> leaf_handler,
       net::URLRequest* request) {
     return leaf_handler.Pass();
   }
 
@@ skipping 282 matching lines @@
   EXPECT_FALSE(raw_ptr_resource_handler_->received_response_completed());
 
   raw_ptr_resource_handler_->Resume();
   base::RunLoop().RunUntilIdle();
 
   EXPECT_TRUE(raw_ptr_resource_handler_->received_response_completed());
   EXPECT_EQ(net::URLRequestStatus::SUCCESS,
             raw_ptr_resource_handler_->status().status());
 }
 
-// Tests that progress is reported correctly while uploading.
-// TODO(andresantoso): Add test for the redirect case.
-TEST_F(ResourceLoaderTest, UploadProgress) {
-  // Set up a test server.
-  net::test_server::EmbeddedTestServer server;
-  ASSERT_TRUE(server.InitializeAndWaitUntilReady());
-  base::FilePath path;
-  PathService::Get(content::DIR_TEST_DATA, &path);
-  server.ServeFilesFromDirectory(path);
-
-  scoped_ptr<net::URLRequest> request(
-      resource_context_.GetRequestContext()->CreateRequest(
-          server.GetURL("/title1.html"),
-          net::DEFAULT_PRIORITY,
-          nullptr /* delegate */));
-
-  // Start an upload.
-  auto stream = new NonChunkedUploadDataStream(10);
-  request->set_upload(make_scoped_ptr(stream));
-
-  SetUpResourceLoader(request.Pass());
-  loader_->StartRequest();
-
-  stream->AppendData("xx");
-  WaitForUploadProgress(2);
-
-  stream->AppendData("yyy");
-  WaitForUploadProgress(5);
-
-  stream->AppendData("zzzzz");
-  WaitForUploadProgress(10);
-}
-
 class ResourceLoaderRedirectToFileTest : public ResourceLoaderTest {
  public:
   ResourceLoaderRedirectToFileTest()
       : file_stream_(NULL),
         redirect_to_file_resource_handler_(NULL) {
   }
 
   base::FilePath temp_path() const { return temp_path_; }
   ShareableFileReference* deletable_file() const {
     return deletable_file_.get();
@@ skipping 310 matching lines @@
   ASSERT_TRUE(
       CertStore::GetInstance()->RetrieveCert(deserialized.cert_id, &cert));
   EXPECT_TRUE(cert->Equals(GetTestCert().get()));
 
   EXPECT_EQ(kTestCertError, deserialized.cert_status);
   EXPECT_EQ(kTestConnectionStatus, deserialized.connection_status);
   EXPECT_EQ(kTestSecurityBits, deserialized.security_bits);
 }
 
 }  // namespace content