Use modified URLRequest::Read() and delegate methods in /appcache/

content/browser/appcache/appcache_url_request_job_unittest.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 "content/browser/appcache/appcache_url_request_job.h"
 
 #include <stdint.h>
 #include <string.h>
 
 #include <memory>
@@ skipping 134 matching lines @@
     scoped_refptr<AppCacheResponseInfo> loaded_info_;
     int64_t loaded_info_id_;
     AppCacheURLRequestJobTest* test_;
   };
 
   class MockURLRequestDelegate : public net::URLRequest::Delegate {
    public:
     explicit MockURLRequestDelegate(AppCacheURLRequestJobTest* test)
         : test_(test),
           received_data_(new net::IOBuffer(kNumBlocks * kBlockSize)),
-          did_receive_headers_(false), amount_received_(0),
-          kill_after_amount_received_(0), kill_with_io_pending_(false) {
-    }
+          did_receive_headers_(false),
+          amount_received_(0),
+          kill_after_amount_received_(0),
+          kill_with_io_pending_(false),
+          request_status_(net::ERR_IO_PENDING) {}
 
-    void OnResponseStarted(net::URLRequest* request) override {
+    void OnResponseStarted(net::URLRequest* request, int net_error) override {
+      DCHECK_NE(net::ERR_IO_PENDING, net_error);
       amount_received_ = 0;
       did_receive_headers_ = false;
-      if (request->status().is_success()) {
+      request_status_ = net_error;
+      if (net_error == net::OK) {
         EXPECT_TRUE(request->response_headers());
         did_receive_headers_ = true;
         received_info_ = request->response_info();
         ReadSome(request);
       } else {
         RequestComplete();
       }
     }
 
     void OnReadCompleted(net::URLRequest* request, int bytes_read) override {
       if (bytes_read > 0) {
         amount_received_ += bytes_read;
+        request_status_ = net::OK;
 
         if (kill_after_amount_received_ && !kill_with_io_pending_) {
           if (amount_received_ >= kill_after_amount_received_) {
             request->Cancel();
             return;
           }
         }
 
         ReadSome(request);
 
         if (kill_after_amount_received_ && kill_with_io_pending_) {
           if (amount_received_ >= kill_after_amount_received_) {
             request->Cancel();
             return;
           }
         }
       } else {
+        request_status_ = bytes_read;
         RequestComplete();
       }
     }
 
     void ReadSome(net::URLRequest* request) {
       DCHECK(amount_received_ + kBlockSize <= kNumBlocks * kBlockSize);
       scoped_refptr<IOBuffer> wrapped_buffer(
           new net::WrappedIOBuffer(received_data_->data() + amount_received_));
-      int bytes_read = 0;
-      EXPECT_FALSE(
-          request->Read(wrapped_buffer.get(), kBlockSize, &bytes_read));
-      EXPECT_EQ(0, bytes_read);
+      EXPECT_EQ(net::ERR_IO_PENDING,
+                request->Read(wrapped_buffer.get(), kBlockSize));
     }
 
     void RequestComplete() {
       test_->ScheduleNextTask();
     }
 
+    int request_status() { return request_status_; }
+
     AppCacheURLRequestJobTest* test_;
     net::HttpResponseInfo received_info_;
     scoped_refptr<net::IOBuffer> received_data_;
     bool did_receive_headers_;
     int amount_received_;
     int kill_after_amount_received_;
     bool kill_with_io_pending_;
+    int request_status_;
   };
 
   // Helper callback to run a test on our io_thread. The io_thread is spun up
   // once and reused for all tests.
   template <class Method>
   void MethodWrapper(Method method) {
     SetUpTest();
     (this->*method)();
   }
 
@@ skipping 315 matching lines @@
 
     // Start the request.
     request_->Start();
 
     // The job should have been picked up.
     EXPECT_FALSE(job_factory_->has_job());
     // Completion is async.
   }
 
   void VerifyDeliverNetworkResponse() {
-    EXPECT_EQ(request_->status().error(),
-              net::ERR_INTERNET_DISCONNECTED);
+    EXPECT_EQ(net::ERR_INTERNET_DISCONNECTED,
+              url_request_delegate_->request_status());
     EXPECT_TRUE(restart_callback_invoked_);
     TestFinished();
   }
 
   // DeliverErrorResponse --------------------------------------------------
 
   void DeliverErrorResponse() {
     // This test has async steps.
     PushNextTask(
         base::Bind(&AppCacheURLRequestJobTest::VerifyDeliverErrorResponse,
@@ skipping 16 matching lines @@
 
     // Start the request.
     request_->Start();
 
     // The job should have been picked up.
     EXPECT_FALSE(job_factory_->has_job());
     // Completion is async.
   }
 
   void VerifyDeliverErrorResponse() {
-    EXPECT_EQ(request_->status().error(), net::ERR_FAILED);
+    EXPECT_EQ(net::ERR_FAILED, url_request_delegate_->request_status());
     TestFinished();
   }
 
   // DeliverSmallAppCachedResponse --------------------------------------
   // "Small" being small enough to read completely in a single
   // request->Read call.
 
   void DeliverSmallAppCachedResponse() {
     // This test has several async steps.
     // 1. Write a small response to response storage.
@@ skipping 46 matching lines @@
           GURL(), 111,
           AppCacheEntry(AppCacheEntry::EXPLICIT, written_response_id_), false);
       ASSERT_TRUE(weak_job);
       EXPECT_TRUE(weak_job->is_delivering_appcache_response());
     }
 
     // Completion is async.
   }
 
   void VerifyDeliverSmallAppCachedResponse() {
-    EXPECT_TRUE(request_->status().is_success());
+    EXPECT_EQ(net::OK, url_request_delegate_->request_status());
     EXPECT_TRUE(CompareHttpResponseInfos(
         write_info_buffer_->http_info.get(),
         &url_request_delegate_->received_info_));
     EXPECT_EQ(5, url_request_delegate_->amount_received_);
     EXPECT_EQ(0, memcmp(kHttpBasicBody,
                         url_request_delegate_->received_data_->data(),
                         strlen(kHttpBasicBody)));
     TestFinished();
   }
 
@@ skipping 26 matching lines @@
     scoped_refptr<IOBuffer> body(new IOBuffer(kBlockSize * 3));
     char* p = body->data();
     for (int i = 0; i < 3; ++i, p += kBlockSize)
       FillData(i + 1, p, kBlockSize);
     std::string raw_headers(kHttpHeaders, arraysize(kHttpHeaders));
     WriteResponse(
         MakeHttpResponseInfo(raw_headers), body.get(), kBlockSize * 3);
   }
 
   void VerifyDeliverLargeAppCachedResponse() {
-    EXPECT_TRUE(request_->status().is_success());
+    EXPECT_EQ(net::OK, url_request_delegate_->request_status());
     EXPECT_TRUE(CompareHttpResponseInfos(
         write_info_buffer_->http_info.get(),
         &url_request_delegate_->received_info_));
     EXPECT_EQ(3072, url_request_delegate_->amount_received_);
     char* p = url_request_delegate_->received_data_->data();
     for (int i = 0; i < 3; ++i, p += kBlockSize)
       EXPECT_TRUE(CheckData(i + 1, p, kBlockSize));
     TestFinished();
   }
 
@@ skipping 37 matching lines @@
 
     // Start the request.
     EXPECT_FALSE(job->has_been_started());
     job_factory_->SetJob(std::move(job));
     request_->Start();
     EXPECT_FALSE(job_factory_->has_job());
     // Completion is async.
   }
 
   void VerifyDeliverPartialResponse() {
-    EXPECT_TRUE(request_->status().is_success());
+    EXPECT_EQ(net::OK, url_request_delegate_->request_status());
     EXPECT_EQ(3, url_request_delegate_->amount_received_);
     EXPECT_EQ(0, memcmp(kHttpBasicBody + 1,
                         url_request_delegate_->received_data_->data(),
                         3));
     net::HttpResponseHeaders* headers =
         url_request_delegate_->received_info_.headers.get();
     EXPECT_EQ(206, headers->response_code());
     EXPECT_EQ(3, headers->GetContentLength());
     int64_t range_start, range_end, object_size;
     EXPECT_TRUE(
@@ skipping 21 matching lines @@
     writer_.reset(service_->storage()->CreateResponseWriter(GURL()));
     written_response_id_ = writer_->response_id();
     WriteLargeResponse();
 
     url_request_delegate_->kill_after_amount_received_ = kBlockSize;
     url_request_delegate_->kill_with_io_pending_ = false;
     // Continues async
   }
 
   void VerifyCancel() {
-    EXPECT_EQ(net::URLRequestStatus::CANCELED,
-              request_->status().status());
+    EXPECT_EQ(net::ERR_ABORTED, url_request_delegate_->request_status());
     TestFinished();
   }
 
   // CancelRequestWithIOPending --------------------------------------
 
   void CancelRequestWithIOPending() {
     // This test has several async steps.
     // 1. Write a large response to response storage.
     // 2. Use net::URLRequest to retrieve it.
     // 3. Cancel the request after data starts coming in.
@@ skipping 77 matching lines @@
 
 TEST_F(AppCacheURLRequestJobTest, CancelRequest) {
   RunTestOnIOThread(&AppCacheURLRequestJobTest::CancelRequest);
 }
 
 TEST_F(AppCacheURLRequestJobTest, CancelRequestWithIOPending) {
   RunTestOnIOThread(&AppCacheURLRequestJobTest::CancelRequestWithIOPending);
 }
 
 }  // namespace content