Improve linearized pdf load/show time.

pdf/document_loader_unittest.cc

Index: pdf/document_loader_unittest.cc
diff --git a/pdf/document_loader_unittest.cc b/pdf/document_loader_unittest.cc
new file mode 100644
index 0000000000000000000000000000000000000000..7107387acf9ad212f0ecf783556d25334669d649
--- /dev/null
+++ b/pdf/document_loader_unittest.cc
@@ -0,0 +1,1112 @@
+// Copyright (c) 2016 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 "pdf/document_loader.h"
+
+#include <memory>
+#include <string>
+
+#include "pdf/url_loader_wrapper.h"
+#include "testing/gmock/include/gmock/gmock.h"
+#include "testing/gtest/include/gtest/gtest.h"
+#include "ui/gfx/range/range.h"
+
+using ::testing::_;
+using ::testing::Mock;
+using ::testing::Sequence;
+using ::testing::NiceMock;
+using ::testing::Return;
+
+namespace chrome_pdf {
+
+namespace {
+class TestURLLoader : public URLLoaderWrapper {
+ public:
+  struct LoaderData {
+    int content_length = -1;
+    bool accept_ranges_bytes = false;
+    bool content_encoded = false;
+    std::string content_type;
+    std::string content_disposition;
+    std::string multipart_boundary;
+    gfx::Range byte_range = gfx::Range::InvalidRange();
+    bool is_multipart = false;
+    int status_code = 0;
+    bool closed = true;
+    gfx::Range open_byte_range = gfx::Range::InvalidRange();
+
+    bool IsWaitRead() const { return wait_read_; }
+    bool IsWaitOpen() const { return wait_open_; }
+    char* buffer() const { return buffer_; }
+    int buffer_size() const { return buffer_size_; }
+
+    void SetReadCallback(const pp::CompletionCallback& read_callback,
+                         char* buffer,
+                         int buffer_size) {
+      wait_read_ = true;
+      did_read_callback_ = read_callback;
+      buffer_ = buffer;
+      buffer_size_ = buffer_size;
+    }
+
+    void SetOpenCallback(const pp::CompletionCallback& open_callback,
+                         gfx::Range req_byte_range) {
+      wait_open_ = true;
+      did_open_callback_ = open_callback;
+      open_byte_range = req_byte_range;
+    }
+
+    void CallOpenCallback(int result) {
+      PP_DCHECK(wait_open_);
+      wait_open_ = false;
+      did_open_callback_.Run(result);
+    }
+
+    void CallReadCallback(int result) {
+      PP_DCHECK(wait_read_);
+      wait_read_ = false;
+      did_read_callback_.Run(result);
+    }
+
+   private:
+    bool wait_open_ = false;
+    pp::CompletionCallback did_open_callback_;
+    bool wait_read_ = false;
+    pp::CompletionCallback did_read_callback_;
+    char* buffer_ = nullptr;
+    int buffer_size_ = 0;
+  };
+
+  explicit TestURLLoader(LoaderData* data) : data_(data) {
+    data_->closed = false;
+  }
+
+  ~TestURLLoader() override { Close(); }
+
+  int GetContentLength() const override { return data_->content_length; }
+
+  bool IsAcceptRangesBytes() const override {
+    return data_->accept_ranges_bytes;
+  }
+
+  bool IsContentEncoded() const override { return data_->content_encoded; }
+
+  std::string GetContentType() const override { return data_->content_type; }
+
+  std::string GetContentDisposition() const override {
+    return data_->content_disposition;
+  }
+
+  int GetStatusCode() const override { return data_->status_code; }
+
+  bool IsMultipart() const override { return data_->is_multipart; }
+
+  bool GetByteRange(int* start, int* end) const override {
+    *start = data_->byte_range.start();
+    *end = data_->byte_range.end();
+    return data_->byte_range.IsValid();
+  }
+
+  void Close() override { data_->closed = true; }
+
+  void OpenRange(const std::string& url,
+                 const std::string& referrer_url,
+                 uint32_t position,
+                 uint32_t size,
+                 const pp::CompletionCallback& cc) override {
+    data_->SetOpenCallback(cc, gfx::Range(position, position + size));
+  }
+
+  void ReadResponseBody(char* buffer,
+                        int buffer_size,
+                        const pp::CompletionCallback& cc) override {
+    data_->SetReadCallback(cc, buffer, buffer_size);
+  }
+
+  bool GetDownloadProgress(int64_t* bytes_received,
+                           int64_t* total_bytes_to_be_received) const override {
+    return false;
+  }
+
+ private:
+  LoaderData* data_;
+};
+
+class TestClient : public DocumentLoader::Client {
+ public:
+  TestClient() { full_page_loader_data()->content_type = "application/pdf"; }
+  ~TestClient() override {}
+  // DocumentLoader::Client overrides:
+  pp::Instance* GetPluginInstance() override { return nullptr; }
+  std::unique_ptr<URLLoaderWrapper> CreateURLLoader() override {
+    return std::unique_ptr<URLLoaderWrapper>(
+        new TestURLLoader(partial_loader_data()));
+  }
+  void OnPendingRequestComplete() override {}
+  void OnNewDataAvailable() override {}
+  void OnDocumentComplete() override {}
+  void OnDocumentCanceled() override {}
+  void CancelBrowserDownload() override {}
+
+  std::unique_ptr<URLLoaderWrapper> CreateFullPageLoader() {
+    return std::unique_ptr<URLLoaderWrapper>(
+        new TestURLLoader(full_page_loader_data()));
+  }
+
+  TestURLLoader::LoaderData* full_page_loader_data() {
+    return &full_page_loader_data_;
+  }
+  TestURLLoader::LoaderData* partial_loader_data() {
+    return &partial_loader_data_;
+  }
+
+  void SetCanUsePartialLoading() {
+    full_page_loader_data()->content_length = 10 * 1024 * 1024;
+    full_page_loader_data()->content_encoded = false;
+    full_page_loader_data()->accept_ranges_bytes = true;
+  }
+
+  void SendAllPartialData() {
+    partial_loader_data_.byte_range = partial_loader_data_.open_byte_range;
+    partial_loader_data_.CallOpenCallback(0);
+    uint32_t length = partial_loader_data_.byte_range.length();
+    while (length > 0) {
+      const uint32_t part_len = std::min(
+          length, static_cast<uint32_t>(DocumentLoader::kDefaultRequestSize));
+      partial_loader_data_.CallReadCallback(part_len);
+      length -= part_len;
+    }
+    if (partial_loader_data_.IsWaitRead()) {
+      partial_loader_data_.CallReadCallback(0);
+    }
+  }
+
+ private:
+  TestURLLoader::LoaderData full_page_loader_data_;
+  TestURLLoader::LoaderData partial_loader_data_;
+};
+
+class MockClient : public TestClient {
+ public:
+  MOCK_METHOD0(OnPendingRequestComplete, void());
+  MOCK_METHOD0(OnNewDataAvailable, void());
+  MOCK_METHOD0(OnDocumentComplete, void());
+  MOCK_METHOD0(OnDocumentCanceled, void());
+};
+}  // namespace
+
+class DocumentLoaderTest : public ::testing::Test {
+ public:
+  DocumentLoaderTest() {}
+  ~DocumentLoaderTest() override {}
+  void SetUp() override {}
+  void TearDown() override {}
+};
+
+TEST_F(DocumentLoaderTest, CanStartPartialLoading) {
+  TestClient client;
+  client.full_page_loader_data()->content_length = 1 * 1024 * 1024;
+  client.full_page_loader_data()->content_encoded = false;
+  client.full_page_loader_data()->accept_ranges_bytes = true;
+  {
+    DocumentLoader loader(&client);
+    loader.Init(client.CreateFullPageLoader(), "http://url.com");
+    loader.RequestData(1000000, 1);
+    EXPECT_FALSE(loader.is_partial_loader_active());
+    // Always send initial data from FullPageLoader.
+    client.full_page_loader_data()->CallReadCallback(
+        DocumentLoader::kDefaultRequestSize);
+    EXPECT_TRUE(loader.is_partial_loader_active());
+  }
+  {
+    client.full_page_loader_data()->content_length =
+        DocumentLoader::kDefaultRequestSize * 2;
+    DocumentLoader loader(&client);
+    loader.Init(client.CreateFullPageLoader(), "http://url.com");
+    loader.RequestData(1000000, 1);
+    EXPECT_FALSE(loader.is_partial_loader_active());
+    // Always send initial data from FullPageLoader.
+    client.full_page_loader_data()->CallReadCallback(
+        DocumentLoader::kDefaultRequestSize);
+    EXPECT_FALSE(loader.is_partial_loader_active());
+    client.full_page_loader_data()->content_length = 1 * 1024 * 1024;
+  }
+  {
+    client.full_page_loader_data()->content_encoded = true;
+    DocumentLoader loader(&client);
+    loader.Init(client.CreateFullPageLoader(), "http://url.com");
+    loader.RequestData(1000000, 1);
+    EXPECT_FALSE(loader.is_partial_loader_active());
+    // Always send initial data from FullPageLoader.
+    client.full_page_loader_data()->CallReadCallback(
+        DocumentLoader::kDefaultRequestSize);
+    EXPECT_FALSE(loader.is_partial_loader_active());
+    client.full_page_loader_data()->content_encoded = false;
+  }
+  {
+    client.full_page_loader_data()->accept_ranges_bytes = false;
+    DocumentLoader loader(&client);
+    loader.Init(client.CreateFullPageLoader(), "http://url.com");
+    loader.RequestData(1000000, 1);
+    EXPECT_FALSE(loader.is_partial_loader_active());
+    // Always send initial data from FullPageLoader.
+    client.full_page_loader_data()->CallReadCallback(
+        DocumentLoader::kDefaultRequestSize);
+    EXPECT_FALSE(loader.is_partial_loader_active());
+    client.full_page_loader_data()->accept_ranges_bytes = true;
+  }
+  {
+    DocumentLoader loader(&client);
+    loader.SetPartialLoadingEnabled(false);
+    loader.Init(client.CreateFullPageLoader(), "http://url.com");
+    // We should not start partial loading if requested data is beside full page
+    // loading position.
+    loader.RequestData(DocumentLoader::kDefaultRequestSize, 1);
+    EXPECT_FALSE(loader.is_partial_loader_active());
+    // Always send initial data from FullPageLoader.
+    client.full_page_loader_data()->CallReadCallback(
+        DocumentLoader::kDefaultRequestSize);
+    EXPECT_FALSE(loader.is_partial_loader_active());
+  }
+  {
+    DocumentLoader loader(&client);
+    loader.SetPartialLoadingEnabled(false);
+    loader.Init(client.CreateFullPageLoader(), "http://url.com");
+    loader.RequestData(1000000, 1);
+    EXPECT_FALSE(loader.is_partial_loader_active());
+    // Always send initial data from FullPageLoader.
+    client.full_page_loader_data()->CallReadCallback(
+        DocumentLoader::kDefaultRequestSize);
+    EXPECT_FALSE(loader.is_partial_loader_active());
+  }
+}
+
+TEST_F(DocumentLoaderTest, PartialLoadingSimple) {
+  TestClient client;
+  client.SetCanUsePartialLoading();
+
+  DocumentLoader loader(&client);
+  loader.Init(client.CreateFullPageLoader(), "http://url.com");
+
+  // While we have not requests, we shold not start partial loading.
+  EXPECT_FALSE(loader.is_partial_loader_active());
+
+  loader.RequestData(5000000, 1);
+
+  EXPECT_FALSE(client.partial_loader_data()->IsWaitOpen());
+  EXPECT_FALSE(loader.is_partial_loader_active());
+
+  // Always send initial data from FullPageLoader.
+  client.full_page_loader_data()->CallReadCallback(
+      DocumentLoader::kDefaultRequestSize);
+
+  // Partial loader should request headers.
+  EXPECT_TRUE(client.partial_loader_data()->IsWaitOpen());
+  EXPECT_TRUE(loader.is_partial_loader_active());
+  // Loader should be stopped.
+  EXPECT_TRUE(client.full_page_loader_data()->closed);
+
+  EXPECT_EQ(client.partial_loader_data()->open_byte_range.ToString(),
+            "{4980736,10485760}");
+}
+
+TEST_F(DocumentLoaderTest, PartialLoadingBackOrder) {
+  TestClient client;
+  client.SetCanUsePartialLoading();
+
+  DocumentLoader loader(&client);
+  loader.Init(client.CreateFullPageLoader(), "http://url.com");
+
+  // While we have not requests, we shold not start partial loading.
+  EXPECT_FALSE(loader.is_partial_loader_active());
+
+  loader.RequestData(client.full_page_loader_data()->content_length - 1, 1);
+
+  EXPECT_FALSE(client.partial_loader_data()->IsWaitOpen());
+  EXPECT_FALSE(loader.is_partial_loader_active());
+
+  // Always send initial data from FullPageLoader.
+  client.full_page_loader_data()->CallReadCallback(
+      DocumentLoader::kDefaultRequestSize);
+
+  // Partial loader should request headers.
+  EXPECT_TRUE(client.partial_loader_data()->IsWaitOpen());
+  EXPECT_TRUE(loader.is_partial_loader_active());
+  // Loader should be stopped.
+  EXPECT_TRUE(client.full_page_loader_data()->closed);
+
+  // Requested range should be enlarged.
+  EXPECT_GT(client.partial_loader_data()->open_byte_range.length(), 1u);
+  EXPECT_EQ(client.partial_loader_data()->open_byte_range.ToString(),
+            "{9830400,10485760}");
+}
+
+TEST_F(DocumentLoaderTest, CompleteWithoutPartial) {
+  TestClient client;
+  client.SetCanUsePartialLoading();
+  DocumentLoader loader(&client);
+  loader.Init(client.CreateFullPageLoader(), "http://url.com");
+  EXPECT_FALSE(client.full_page_loader_data()->closed);
+  while (client.full_page_loader_data()->IsWaitRead()) {
+    client.full_page_loader_data()->CallReadCallback(1000);
+  }
+  EXPECT_TRUE(loader.IsDocumentComplete());
+  EXPECT_TRUE(client.full_page_loader_data()->closed);
+}
+
+TEST_F(DocumentLoaderTest, ErrorDownloadFullDocument) {
+  TestClient client;
+  client.SetCanUsePartialLoading();
+  DocumentLoader loader(&client);
+  loader.Init(client.CreateFullPageLoader(), "http://url.com");
+  EXPECT_TRUE(client.full_page_loader_data()->IsWaitRead());
+  EXPECT_FALSE(client.full_page_loader_data()->closed);
+  client.full_page_loader_data()->CallReadCallback(-3);
+  EXPECT_TRUE(client.full_page_loader_data()->closed);
+  EXPECT_FALSE(loader.IsDocumentComplete());
+}
+
+TEST_F(DocumentLoaderTest, CompleteNoContentLength) {
+  TestClient client;
+  DocumentLoader loader(&client);
+  loader.Init(client.CreateFullPageLoader(), "http://url.com");
+  EXPECT_FALSE(client.full_page_loader_data()->closed);
+  for (int i = 0; i < 10; ++i) {
+    EXPECT_TRUE(client.full_page_loader_data()->IsWaitRead());
+    client.full_page_loader_data()->CallReadCallback(1000);
+  }
+  EXPECT_TRUE(client.full_page_loader_data()->IsWaitRead());
+  client.full_page_loader_data()->CallReadCallback(0);
+  EXPECT_EQ(loader.GetDocumentSize(), 10000ul);
+  EXPECT_TRUE(loader.IsDocumentComplete());
+  EXPECT_TRUE(client.full_page_loader_data()->closed);
+}
+
+TEST_F(DocumentLoaderTest, CompleteWithPartial) {
+  TestClient client;
+  client.SetCanUsePartialLoading();
+  client.full_page_loader_data()->content_length =
+      DocumentLoader::kDefaultRequestSize * 20;
+  DocumentLoader loader(&client);
+  loader.Init(client.CreateFullPageLoader(), "http://url.com");
+  loader.RequestData(19 * DocumentLoader::kDefaultRequestSize,
+                     DocumentLoader::kDefaultRequestSize);
+  EXPECT_FALSE(client.full_page_loader_data()->closed);
+  EXPECT_FALSE(client.partial_loader_data()->IsWaitRead());
+  EXPECT_FALSE(client.partial_loader_data()->IsWaitOpen());
+
+  // Always send initial data from FullPageLoader.
+  client.full_page_loader_data()->CallReadCallback(
+      DocumentLoader::kDefaultRequestSize);
+  EXPECT_TRUE(client.full_page_loader_data()->closed);
+  EXPECT_FALSE(client.partial_loader_data()->closed);
+
+  client.SendAllPartialData();
+  // Now we should send other document data.
+  client.SendAllPartialData();
+  EXPECT_TRUE(client.full_page_loader_data()->closed);
+  EXPECT_TRUE(client.partial_loader_data()->closed);
+}
+
+TEST_F(DocumentLoaderTest, PartialRequestLastChunk) {
+  const uint32_t kLastChunkSize = 300;
+  TestClient client;
+  client.SetCanUsePartialLoading();
+  client.full_page_loader_data()->content_length =
+      DocumentLoader::kDefaultRequestSize * 20 + kLastChunkSize;
+  DocumentLoader loader(&client);
+  loader.Init(client.CreateFullPageLoader(), "http://url.com");
+  loader.RequestData(20 * DocumentLoader::kDefaultRequestSize, 1);
+
+  // Always send initial data from FullPageLoader.
+  client.full_page_loader_data()->CallReadCallback(
+      DocumentLoader::kDefaultRequestSize);
+
+  EXPECT_TRUE(client.partial_loader_data()->IsWaitOpen());
+  EXPECT_EQ(client.partial_loader_data()->open_byte_range.end(),
+            client.full_page_loader_data()->content_length);
+  client.partial_loader_data()->byte_range =
+      client.partial_loader_data()->open_byte_range;
+  client.partial_loader_data()->CallOpenCallback(0);
+  uint32_t data_length = client.partial_loader_data()->byte_range.length();
+  while (data_length > DocumentLoader::kDefaultRequestSize) {
+    client.partial_loader_data()->CallReadCallback(
+        DocumentLoader::kDefaultRequestSize);
+    data_length -= DocumentLoader::kDefaultRequestSize;
+  }
+  EXPECT_EQ(kLastChunkSize, data_length);
+  client.partial_loader_data()->CallReadCallback(kLastChunkSize);
+  EXPECT_TRUE(loader.IsDataAvailable(DocumentLoader::kDefaultRequestSize * 20,
+                                     kLastChunkSize));
+}
+
+TEST_F(DocumentLoaderTest, DocumentSize) {
+  TestClient client;
+  client.SetCanUsePartialLoading();
+  client.full_page_loader_data()->content_length = 123456789;
+  DocumentLoader loader(&client);
+  loader.Init(client.CreateFullPageLoader(), "http://url.com");
+  EXPECT_EQ(static_cast<int>(loader.GetDocumentSize()),
+            client.full_page_loader_data()->content_length);
+}
+
+TEST_F(DocumentLoaderTest, DocumentSizeNoContentLength) {
+  TestClient client;
+  DocumentLoader loader(&client);
+  loader.Init(client.CreateFullPageLoader(), "http://url.com");
+  EXPECT_EQ(loader.GetDocumentSize(), 0ul);
+  client.full_page_loader_data()->CallReadCallback(
+      DocumentLoader::kDefaultRequestSize);
+  client.full_page_loader_data()->CallReadCallback(1000);
+  client.full_page_loader_data()->CallReadCallback(500);
+  client.full_page_loader_data()->CallReadCallback(0);
+  EXPECT_EQ(static_cast<int>(loader.GetDocumentSize()),
+            DocumentLoader::kDefaultRequestSize + 1000 + 500);
+  EXPECT_TRUE(loader.IsDocumentComplete());
+}
+
+TEST_F(DocumentLoaderTest, ClearPendingRequests) {
+  TestClient client;
+  client.SetCanUsePartialLoading();
+  client.full_page_loader_data()->content_length =
+      DocumentLoader::kDefaultRequestSize * 100 + 58383;
+  DocumentLoader loader(&client);
+  loader.Init(client.CreateFullPageLoader(), "http://url.com");
+  loader.RequestData(17 * DocumentLoader::kDefaultRequestSize + 100, 10);
+  loader.ClearPendingRequests();
+  loader.RequestData(15 * DocumentLoader::kDefaultRequestSize + 200, 20);
+  // pending requests are accumulating, and will be processed after initial data
+  // load.
+  EXPECT_FALSE(client.partial_loader_data()->IsWaitOpen());
+
+  // Send initial data from FullPageLoader.
+  client.full_page_loader_data()->CallReadCallback(
+      DocumentLoader::kDefaultRequestSize);
+
+  {
+    EXPECT_TRUE(client.partial_loader_data()->IsWaitOpen());
+    const gfx::Range range_requested(15 * DocumentLoader::kDefaultRequestSize,
+                                     16 * DocumentLoader::kDefaultRequestSize);
+    EXPECT_EQ(client.partial_loader_data()->open_byte_range.start(),
+              range_requested.start());
+    EXPECT_GE(client.partial_loader_data()->open_byte_range.end(),
+              range_requested.end());
+    client.partial_loader_data()->byte_range =
+        client.partial_loader_data()->open_byte_range;
+  }
+  // clear requests before Open callback.
+  loader.ClearPendingRequests();
+  // Current request should continue loading.
+  EXPECT_TRUE(client.partial_loader_data()->IsWaitOpen());
+  client.partial_loader_data()->CallOpenCallback(0);
+  client.partial_loader_data()->CallReadCallback(
+      DocumentLoader::kDefaultRequestSize);
+  EXPECT_FALSE(client.partial_loader_data()->closed);
+  // Current request should continue loading, because not other requests queued.
+
+  loader.RequestData(18 * DocumentLoader::kDefaultRequestSize + 200, 20);
+  // Requests queue is processed only on data receving.
+  client.partial_loader_data()->CallReadCallback(
+      DocumentLoader::kDefaultRequestSize);
+  // new requset with in close distance from current loading. Loading do not
+  // restarted.
+  EXPECT_FALSE(client.partial_loader_data()->IsWaitOpen());
+
+  loader.ClearPendingRequests();
+  // request again two.
+  loader.RequestData(60 * DocumentLoader::kDefaultRequestSize + 100, 10);
+  loader.RequestData(35 * DocumentLoader::kDefaultRequestSize + 200, 20);
+  // Requests queue is processed only on data receving.
+  client.partial_loader_data()->CallReadCallback(
+      DocumentLoader::kDefaultRequestSize);
+  {
+    // new requset not with in close distance from current loading.
+    // Loading should be restarted.
+    EXPECT_TRUE(client.partial_loader_data()->IsWaitOpen());
+    // The first requested chunk should be processed.
+    const gfx::Range range_requested(35 * DocumentLoader::kDefaultRequestSize,
+                                     36 * DocumentLoader::kDefaultRequestSize);
+    EXPECT_EQ(client.partial_loader_data()->open_byte_range.start(),
+              range_requested.start());
+    EXPECT_GE(client.partial_loader_data()->open_byte_range.end(),
+              range_requested.end());
+    client.partial_loader_data()->byte_range =
+        client.partial_loader_data()->open_byte_range;
+  }
+  EXPECT_TRUE(client.partial_loader_data()->IsWaitOpen());
+  client.partial_loader_data()->CallOpenCallback(0);
+  // Override pending requests.
+  loader.ClearPendingRequests();
+  loader.RequestData(70 * DocumentLoader::kDefaultRequestSize + 100, 10);
+
+  // Requests queue is processed only on data receving.
+  client.partial_loader_data()->CallReadCallback(
+      DocumentLoader::kDefaultRequestSize);
+  {
+    // New requset not with in close distance from current loading.
+    // Loading should be restarted .
+    EXPECT_TRUE(client.partial_loader_data()->IsWaitOpen());
+    // The first requested chunk should be processed.
+    const gfx::Range range_requested(70 * DocumentLoader::kDefaultRequestSize,
+                                     71 * DocumentLoader::kDefaultRequestSize);
+    EXPECT_EQ(client.partial_loader_data()->open_byte_range.start(),
+              range_requested.start());
+    EXPECT_GE(client.partial_loader_data()->open_byte_range.end(),
+              range_requested.end());
+    client.partial_loader_data()->byte_range =
+        client.partial_loader_data()->open_byte_range;
+  }
+  EXPECT_TRUE(client.partial_loader_data()->IsWaitOpen());
+}
+
+TEST_F(DocumentLoaderTest, GetBlock) {
+  char buffer[DocumentLoader::kDefaultRequestSize];
+  TestClient client;
+  client.SetCanUsePartialLoading();
+  client.full_page_loader_data()->content_length =
+      DocumentLoader::kDefaultRequestSize * 20 + 58383;
+  DocumentLoader loader(&client);
+  loader.Init(client.CreateFullPageLoader(), "http://url.com");
+  EXPECT_FALSE(loader.GetBlock(0, 1000, buffer));
+  client.full_page_loader_data()->CallReadCallback(
+      DocumentLoader::kDefaultRequestSize);
+  EXPECT_TRUE(loader.GetBlock(0, 1000, buffer));
+  EXPECT_FALSE(
+      loader.GetBlock(DocumentLoader::kDefaultRequestSize, 1500, buffer));
+  client.full_page_loader_data()->CallReadCallback(
+      DocumentLoader::kDefaultRequestSize);
+  EXPECT_TRUE(
+      loader.GetBlock(DocumentLoader::kDefaultRequestSize, 1500, buffer));
+
+  EXPECT_FALSE(
+      loader.GetBlock(17 * DocumentLoader::kDefaultRequestSize, 3000, buffer));
+  loader.RequestData(17 * DocumentLoader::kDefaultRequestSize + 100, 10);
+  EXPECT_FALSE(
+      loader.GetBlock(17 * DocumentLoader::kDefaultRequestSize, 3000, buffer));
+
+  // Requests queue is processed only on data receving.
+  client.full_page_loader_data()->CallReadCallback(
+      DocumentLoader::kDefaultRequestSize);
+
+  client.SendAllPartialData();
+  EXPECT_TRUE(
+      loader.GetBlock(17 * DocumentLoader::kDefaultRequestSize, 3000, buffer));
+}
+
+TEST_F(DocumentLoaderTest, IsDataAvailable) {
+  TestClient client;
+  client.SetCanUsePartialLoading();
+  client.full_page_loader_data()->content_length =
+      DocumentLoader::kDefaultRequestSize * 20 + 58383;
+  DocumentLoader loader(&client);
+  loader.Init(client.CreateFullPageLoader(), "http://url.com");
+  EXPECT_FALSE(loader.IsDataAvailable(0, 1000));
+  client.full_page_loader_data()->CallReadCallback(
+      DocumentLoader::kDefaultRequestSize);
+  EXPECT_TRUE(loader.IsDataAvailable(0, 1000));
+  EXPECT_FALSE(
+      loader.IsDataAvailable(DocumentLoader::kDefaultRequestSize, 1500));
+  client.full_page_loader_data()->CallReadCallback(
+      DocumentLoader::kDefaultRequestSize);
+  EXPECT_TRUE(
+      loader.IsDataAvailable(DocumentLoader::kDefaultRequestSize, 1500));
+
+  EXPECT_FALSE(
+      loader.IsDataAvailable(17 * DocumentLoader::kDefaultRequestSize, 3000));
+  loader.RequestData(17 * DocumentLoader::kDefaultRequestSize + 100, 10);
+  EXPECT_FALSE(
+      loader.IsDataAvailable(17 * DocumentLoader::kDefaultRequestSize, 3000));
+
+  // Requests queue is processed only on data receving.
+  client.full_page_loader_data()->CallReadCallback(
+      DocumentLoader::kDefaultRequestSize);
+
+  client.SendAllPartialData();
+  EXPECT_TRUE(
+      loader.IsDataAvailable(17 * DocumentLoader::kDefaultRequestSize, 3000));
+}
+
+TEST_F(DocumentLoaderTest, RequestData) {
+  TestClient client;
+  client.SetCanUsePartialLoading();
+  client.full_page_loader_data()->content_length =
+      DocumentLoader::kDefaultRequestSize * 100 + 58383;
+  DocumentLoader loader(&client);
+  loader.Init(client.CreateFullPageLoader(), "http://url.com");
+  loader.RequestData(37 * DocumentLoader::kDefaultRequestSize + 200, 10);
+  loader.RequestData(25 * DocumentLoader::kDefaultRequestSize + 600, 100);
+  loader.RequestData(13 * DocumentLoader::kDefaultRequestSize + 900, 500);
+
+  // Send initial data from FullPageLoader.
+  client.full_page_loader_data()->CallReadCallback(
+      DocumentLoader::kDefaultRequestSize);
+
+  {
+    EXPECT_TRUE(client.partial_loader_data()->IsWaitOpen());
+    const gfx::Range range_requested(13 * DocumentLoader::kDefaultRequestSize,
+                                     14 * DocumentLoader::kDefaultRequestSize);
+    EXPECT_EQ(client.partial_loader_data()->open_byte_range.start(),
+              range_requested.start());
+    EXPECT_GE(client.partial_loader_data()->open_byte_range.end(),
+              range_requested.end());
+    client.partial_loader_data()->byte_range =
+        client.partial_loader_data()->open_byte_range;
+  }
+  client.partial_loader_data()->CallOpenCallback(0);
+  // Override pending requests.
+  loader.ClearPendingRequests();
+  loader.RequestData(38 * DocumentLoader::kDefaultRequestSize + 200, 10);
+  loader.RequestData(26 * DocumentLoader::kDefaultRequestSize + 600, 100);
+  // Requests queue is processed only on data receving.
+  client.partial_loader_data()->CallReadCallback(
+      DocumentLoader::kDefaultRequestSize);
+  {
+    EXPECT_TRUE(client.partial_loader_data()->IsWaitOpen());
+    const gfx::Range range_requested(26 * DocumentLoader::kDefaultRequestSize,
+                                     27 * DocumentLoader::kDefaultRequestSize);
+    EXPECT_EQ(client.partial_loader_data()->open_byte_range.start(),
+              range_requested.start());
+    EXPECT_GE(client.partial_loader_data()->open_byte_range.end(),
+              range_requested.end());
+    client.partial_loader_data()->byte_range =
+        client.partial_loader_data()->open_byte_range;
+  }
+  client.partial_loader_data()->CallOpenCallback(0);
+  // Override pending requests.
+  loader.ClearPendingRequests();
+  loader.RequestData(39 * DocumentLoader::kDefaultRequestSize + 200, 10);
+  // Requests queue is processed only on data receving.
+  client.partial_loader_data()->CallReadCallback(
+      DocumentLoader::kDefaultRequestSize);
+  {
+    EXPECT_TRUE(client.partial_loader_data()->IsWaitOpen());
+    const gfx::Range range_requested(39 * DocumentLoader::kDefaultRequestSize,
+                                     40 * DocumentLoader::kDefaultRequestSize);
+    EXPECT_EQ(client.partial_loader_data()->open_byte_range.start(),
+              range_requested.start());
+    EXPECT_GE(client.partial_loader_data()->open_byte_range.end(),
+              range_requested.end());
+    client.partial_loader_data()->byte_range =
+        client.partial_loader_data()->open_byte_range;
+  }
+  // Fill all gaps.
+  while (!loader.IsDocumentComplete()) {
+    client.SendAllPartialData();
+  }
+  EXPECT_TRUE(client.partial_loader_data()->closed);
+}
+
+TEST_F(DocumentLoaderTest, DoNotLoadAvailablePartialData) {
+  TestClient client;
+  client.SetCanUsePartialLoading();
+  client.full_page_loader_data()->content_length =
+      DocumentLoader::kDefaultRequestSize * 20 + 58383;
+  DocumentLoader loader(&client);
+  loader.Init(client.CreateFullPageLoader(), "http://url.com");
+  // Send initial data from FullPageLoader.
+  client.full_page_loader_data()->CallReadCallback(
+      DocumentLoader::kDefaultRequestSize);
+
+  // Send more data from FullPageLoader.
+  client.full_page_loader_data()->CallReadCallback(
+      DocumentLoader::kDefaultRequestSize);
+
+  loader.RequestData(2 * DocumentLoader::kDefaultRequestSize + 200, 10);
+
+  // Send more data from FullPageLoader.
+  client.full_page_loader_data()->CallReadCallback(
+      DocumentLoader::kDefaultRequestSize);
+
+  // Partial loading should not started for already available data.
+  EXPECT_TRUE(client.partial_loader_data()->closed);
+}
+
+TEST_F(DocumentLoaderTest, DoNotLoadDataAfterComplete) {
+  TestClient client;
+  client.SetCanUsePartialLoading();
+  client.full_page_loader_data()->content_length =
+      DocumentLoader::kDefaultRequestSize * 20;
+  DocumentLoader loader(&client);
+  loader.Init(client.CreateFullPageLoader(), "http://url.com");
+
+  for (int i = 0; i < 20; ++i) {
+    client.full_page_loader_data()->CallReadCallback(
+        DocumentLoader::kDefaultRequestSize);
+  }
+
+  EXPECT_TRUE(loader.IsDocumentComplete());
+
+  loader.RequestData(17 * DocumentLoader::kDefaultRequestSize + 200, 10);
+
+  EXPECT_TRUE(client.partial_loader_data()->closed);
+  EXPECT_TRUE(client.full_page_loader_data()->closed);
+}
+
+TEST_F(DocumentLoaderTest, DoNotLoadPartialDataAboveDocumentSize) {
+  TestClient client;
+  client.SetCanUsePartialLoading();
+  client.full_page_loader_data()->content_length =
+      DocumentLoader::kDefaultRequestSize * 20;
+  DocumentLoader loader(&client);
+  loader.Init(client.CreateFullPageLoader(), "http://url.com");
+
+  loader.RequestData(20 * DocumentLoader::kDefaultRequestSize + 200, 10);
+
+  // Send initial data from FullPageLoader.
+  client.full_page_loader_data()->CallReadCallback(
+      DocumentLoader::kDefaultRequestSize);
+
+  EXPECT_TRUE(client.partial_loader_data()->closed);
+}
+
+TEST_F(DocumentLoaderTest, MergePendingRequests) {
+  TestClient client;
+  client.SetCanUsePartialLoading();
+  client.full_page_loader_data()->content_length =
+      DocumentLoader::kDefaultRequestSize * 50 + 58383;
+  DocumentLoader loader(&client);
+  loader.Init(client.CreateFullPageLoader(), "http://url.com");
+  loader.RequestData(17 * DocumentLoader::kDefaultRequestSize + 200, 10);
+  loader.RequestData(16 * DocumentLoader::kDefaultRequestSize + 600, 100);
+
+  // Send initial data from FullPageLoader.
+  client.full_page_loader_data()->CallReadCallback(
+      DocumentLoader::kDefaultRequestSize);
+
+  const gfx::Range range_requested(16 * DocumentLoader::kDefaultRequestSize,
+                                   18 * DocumentLoader::kDefaultRequestSize);
+  EXPECT_EQ(client.partial_loader_data()->open_byte_range.start(),
+            range_requested.start());
+  EXPECT_GE(client.partial_loader_data()->open_byte_range.end(),
+            range_requested.end());
+
+  EXPECT_TRUE(client.partial_loader_data()->IsWaitOpen());
+
+  // Fill all gaps.
+  while (!loader.IsDocumentComplete()) {
+    client.SendAllPartialData();
+  }
+  EXPECT_TRUE(client.partial_loader_data()->closed);
+}
+
+TEST_F(DocumentLoaderTest, PartialStopOnStatusCodeError) {
+  TestClient client;
+  client.SetCanUsePartialLoading();
+  client.full_page_loader_data()->content_length =
+      DocumentLoader::kDefaultRequestSize * 20;
+  DocumentLoader loader(&client);
+  loader.Init(client.CreateFullPageLoader(), "http://url.com");
+
+  loader.RequestData(17 * DocumentLoader::kDefaultRequestSize + 200, 10);
+
+  // Send initial data from FullPageLoader.
+  client.full_page_loader_data()->CallReadCallback(
+      DocumentLoader::kDefaultRequestSize);
+
+  EXPECT_TRUE(client.partial_loader_data()->IsWaitOpen());
+  client.partial_loader_data()->status_code = 404;
+  client.partial_loader_data()->CallOpenCallback(0);
+  EXPECT_TRUE(client.partial_loader_data()->closed);
+}
+
+TEST_F(DocumentLoaderTest,
+       PartialAsFullDocumentLoadingRangeRequestNoRangeField) {
+  TestClient client;
+  client.SetCanUsePartialLoading();
+  client.full_page_loader_data()->content_length =
+      DocumentLoader::kDefaultRequestSize * 20;
+  DocumentLoader loader(&client);
+  loader.Init(client.CreateFullPageLoader(), "http://url.com");
+
+  loader.RequestData(17 * DocumentLoader::kDefaultRequestSize + 200, 10);
+
+  // Send initial data from FullPageLoader.
+  client.full_page_loader_data()->CallReadCallback(
+      DocumentLoader::kDefaultRequestSize);
+
+  EXPECT_TRUE(client.partial_loader_data()->IsWaitOpen());
+  client.partial_loader_data()->byte_range = gfx::Range::InvalidRange();
+  client.partial_loader_data()->CallOpenCallback(0);
+  EXPECT_FALSE(client.partial_loader_data()->closed);
+  // partial loader is used to load whole page, like full page loader.
+  EXPECT_FALSE(loader.is_partial_loader_active());
+}
+
+TEST_F(DocumentLoaderTest, PartialMultiPart) {
+  TestClient client;
+  client.SetCanUsePartialLoading();
+  client.full_page_loader_data()->content_length =
+      DocumentLoader::kDefaultRequestSize * 20;
+  DocumentLoader loader(&client);
+  loader.Init(client.CreateFullPageLoader(), "http://url.com");
+
+  loader.RequestData(17 * DocumentLoader::kDefaultRequestSize + 200, 10);
+
+  // Send initial data from FullPageLoader.
+  client.full_page_loader_data()->CallReadCallback(
+      DocumentLoader::kDefaultRequestSize);
+
+  EXPECT_TRUE(client.partial_loader_data()->IsWaitOpen());
+  client.partial_loader_data()->is_multipart = true;
+  client.partial_loader_data()->CallOpenCallback(0);
+  client.partial_loader_data()->byte_range =
+      gfx::Range(17 * DocumentLoader::kDefaultRequestSize,
+                 18 * DocumentLoader::kDefaultRequestSize);
+  client.partial_loader_data()->CallReadCallback(
+      DocumentLoader::kDefaultRequestSize);
+  EXPECT_TRUE(loader.IsDataAvailable(17 * DocumentLoader::kDefaultRequestSize,
+                                     DocumentLoader::kDefaultRequestSize));
+}
+
+TEST_F(DocumentLoaderTest, PartialMultiPartRangeError) {
+  TestClient client;
+  client.SetCanUsePartialLoading();
+  client.full_page_loader_data()->content_length =
+      DocumentLoader::kDefaultRequestSize * 20;
+  DocumentLoader loader(&client);
+  loader.Init(client.CreateFullPageLoader(), "http://url.com");
+
+  loader.RequestData(17 * DocumentLoader::kDefaultRequestSize + 200, 10);
+
+  // Send initial data from FullPageLoader.
+  client.full_page_loader_data()->CallReadCallback(
+      DocumentLoader::kDefaultRequestSize);
+
+  EXPECT_TRUE(client.partial_loader_data()->IsWaitOpen());
+  client.partial_loader_data()->is_multipart = true;
+  client.partial_loader_data()->CallOpenCallback(0);
+  client.partial_loader_data()->byte_range = gfx::Range::InvalidRange();
+  client.partial_loader_data()->CallReadCallback(
+      DocumentLoader::kDefaultRequestSize);
+  EXPECT_FALSE(loader.IsDataAvailable(17 * DocumentLoader::kDefaultRequestSize,
+                                      DocumentLoader::kDefaultRequestSize));
+  EXPECT_TRUE(client.partial_loader_data()->closed);
+}
+
+TEST_F(DocumentLoaderTest, PartialConnectionErrorOnOpen) {
+  TestClient client;
+  client.SetCanUsePartialLoading();
+  client.full_page_loader_data()->content_length =
+      DocumentLoader::kDefaultRequestSize * 20;
+  DocumentLoader loader(&client);
+  loader.Init(client.CreateFullPageLoader(), "http://url.com");
+
+  loader.RequestData(17 * DocumentLoader::kDefaultRequestSize + 200, 10);
+
+  // Send initial data from FullPageLoader.
+  client.full_page_loader_data()->CallReadCallback(
+      DocumentLoader::kDefaultRequestSize);
+
+  EXPECT_TRUE(client.partial_loader_data()->IsWaitOpen());
+  client.partial_loader_data()->CallOpenCallback(-3);
+  EXPECT_TRUE(client.partial_loader_data()->closed);
+
+  // Partial loading should not restart after any error.
+  loader.RequestData(18 * DocumentLoader::kDefaultRequestSize + 200, 10);
+
+  EXPECT_FALSE(client.partial_loader_data()->IsWaitOpen());
+  EXPECT_TRUE(client.partial_loader_data()->closed);
+}
+
+TEST_F(DocumentLoaderTest, PartialConnectionErrorOnRead) {
+  TestClient client;
+  client.SetCanUsePartialLoading();
+  client.full_page_loader_data()->content_length =
+      DocumentLoader::kDefaultRequestSize * 20;
+  DocumentLoader loader(&client);
+  loader.Init(client.CreateFullPageLoader(), "http://url.com");
+
+  loader.RequestData(17 * DocumentLoader::kDefaultRequestSize + 200, 10);
+
+  // Send initial data from FullPageLoader.
+  client.full_page_loader_data()->CallReadCallback(
+      DocumentLoader::kDefaultRequestSize);
+
+  EXPECT_TRUE(client.partial_loader_data()->IsWaitOpen());
+  client.partial_loader_data()->byte_range =
+      gfx::Range(17 * DocumentLoader::kDefaultRequestSize,
+                 18 * DocumentLoader::kDefaultRequestSize);
+  client.partial_loader_data()->CallOpenCallback(0);
+  EXPECT_TRUE(client.partial_loader_data()->IsWaitRead());
+  client.partial_loader_data()->CallReadCallback(-3);
+  EXPECT_TRUE(client.partial_loader_data()->closed);
+
+  // Partial loading should not restart after any error.
+  loader.RequestData(18 * DocumentLoader::kDefaultRequestSize + 200, 10);
+
+  EXPECT_FALSE(client.partial_loader_data()->IsWaitOpen());
+  EXPECT_TRUE(client.partial_loader_data()->closed);
+}
+
+TEST_F(DocumentLoaderTest, GetProgress) {
+  TestClient client;
+  client.SetCanUsePartialLoading();
+  client.full_page_loader_data()->content_length =
+      DocumentLoader::kDefaultRequestSize * 20;
+  DocumentLoader loader(&client);
+  loader.Init(client.CreateFullPageLoader(), "http://url.com");
+  EXPECT_EQ(loader.GetProgress(), 0.);
+
+  for (int i = 0; i < 20; ++i) {
+    EXPECT_EQ(static_cast<int>(loader.GetProgress() * 100), i * 100 / 20);
+    client.full_page_loader_data()->CallReadCallback(
+        DocumentLoader::kDefaultRequestSize);
+  }
+  EXPECT_EQ(loader.GetProgress(), 1.);
+}
+
+TEST_F(DocumentLoaderTest, GetProgressNoContentLength) {
+  TestClient client;
+  DocumentLoader loader(&client);
+  loader.Init(client.CreateFullPageLoader(), "http://url.com");
+  EXPECT_EQ(loader.GetProgress(), -1.);
+
+  for (int i = 0; i < 20; ++i) {
+    EXPECT_EQ(loader.GetProgress(), -1.);
+    client.full_page_loader_data()->CallReadCallback(
+        DocumentLoader::kDefaultRequestSize);
+  }
+  client.full_page_loader_data()->CallReadCallback(0);
+  EXPECT_EQ(loader.GetProgress(), 1.);
+}
+
+TEST_F(DocumentLoaderTest, ClientCompleteCallbacks) {
+  MockClient client;
+  client.SetCanUsePartialLoading();
+  client.full_page_loader_data()->content_length =
+      DocumentLoader::kDefaultRequestSize * 20;
+  DocumentLoader loader(&client);
+  loader.Init(client.CreateFullPageLoader(), "http://url.com");
+
+  EXPECT_CALL(client, OnDocumentComplete()).Times(0);
+  for (int i = 0; i < 19; ++i) {
+    client.full_page_loader_data()->CallReadCallback(
+        DocumentLoader::kDefaultRequestSize);
+  }
+  Mock::VerifyAndClear(&client);
+
+  EXPECT_CALL(client, OnDocumentComplete()).Times(1);
+  client.full_page_loader_data()->CallReadCallback(
+      DocumentLoader::kDefaultRequestSize);
+  Mock::VerifyAndClear(&client);
+}
+
+TEST_F(DocumentLoaderTest, ClientCompleteCallbacksNoContentLength) {
+  MockClient client;
+  DocumentLoader loader(&client);
+  loader.Init(client.CreateFullPageLoader(), "http://url.com");
+
+  EXPECT_CALL(client, OnDocumentCanceled()).Times(0);
+  EXPECT_CALL(client, OnDocumentComplete()).Times(0);
+  for (int i = 0; i < 20; ++i) {
+    client.full_page_loader_data()->CallReadCallback(
+        DocumentLoader::kDefaultRequestSize);
+  }
+  Mock::VerifyAndClear(&client);
+
+  EXPECT_CALL(client, OnDocumentCanceled()).Times(0);
+  EXPECT_CALL(client, OnDocumentComplete()).Times(1);
+  client.full_page_loader_data()->CallReadCallback(0);
+  Mock::VerifyAndClear(&client);
+}
+
+TEST_F(DocumentLoaderTest, ClientCancelCallback) {
+  MockClient client;
+  client.SetCanUsePartialLoading();
+  client.full_page_loader_data()->content_length =
+      DocumentLoader::kDefaultRequestSize * 20;
+  DocumentLoader loader(&client);
+  loader.Init(client.CreateFullPageLoader(), "http://url.com");
+
+  EXPECT_CALL(client, OnDocumentCanceled()).Times(0);
+  EXPECT_CALL(client, OnDocumentComplete()).Times(0);
+  for (int i = 0; i < 10; ++i) {
+    client.full_page_loader_data()->CallReadCallback(
+        DocumentLoader::kDefaultRequestSize);
+  }
+  Mock::VerifyAndClear(&client);
+
+  EXPECT_CALL(client, OnDocumentComplete()).Times(0);
+  EXPECT_CALL(client, OnDocumentCanceled()).Times(1);
+  client.full_page_loader_data()->CallReadCallback(-3);
+  Mock::VerifyAndClear(&client);
+}
+
+TEST_F(DocumentLoaderTest, NewDataAvailable) {
+  MockClient client;
+  client.SetCanUsePartialLoading();
+  client.full_page_loader_data()->content_length =
+      DocumentLoader::kDefaultRequestSize * 20;
+  DocumentLoader loader(&client);
+  loader.Init(client.CreateFullPageLoader(), "http://url.com");
+
+  EXPECT_CALL(client, OnNewDataAvailable()).Times(1);
+  client.full_page_loader_data()->CallReadCallback(
+      DocumentLoader::kDefaultRequestSize);
+  Mock::VerifyAndClear(&client);
+
+  EXPECT_CALL(client, OnNewDataAvailable()).Times(0);
+  client.full_page_loader_data()->CallReadCallback(
+      DocumentLoader::kDefaultRequestSize - 100);
+  Mock::VerifyAndClear(&client);
+
+  EXPECT_CALL(client, OnNewDataAvailable()).Times(1);
+  client.full_page_loader_data()->CallReadCallback(100);
+  Mock::VerifyAndClear(&client);
+}
+
+TEST_F(DocumentLoaderTest, ClientPendingRequestCompleteFullLoader) {
+  MockClient client;
+  client.SetCanUsePartialLoading();
+  DocumentLoader loader(&client);
+  loader.Init(client.CreateFullPageLoader(), "http://url.com");
+
+  loader.RequestData(1000, 4000);
+
+  EXPECT_CALL(client, OnPendingRequestComplete()).Times(1);
+  client.full_page_loader_data()->CallReadCallback(
+      DocumentLoader::kDefaultRequestSize);
+  Mock::VerifyAndClear(&client);
+}
+
+TEST_F(DocumentLoaderTest, ClientPendingRequestCompletePartialLoader) {
+  MockClient client;
+  client.SetCanUsePartialLoading();
+  DocumentLoader loader(&client);
+  loader.Init(client.CreateFullPageLoader(), "http://url.com");
+
+  EXPECT_CALL(client, OnPendingRequestComplete()).Times(1);
+  loader.RequestData(15 * DocumentLoader::kDefaultRequestSize + 4000, 4000);
+
+  // Always send initial data from FullPageLoader.
+  client.full_page_loader_data()->CallReadCallback(
+      DocumentLoader::kDefaultRequestSize);
+
+  client.SendAllPartialData();
+  Mock::VerifyAndClear(&client);
+}
+
+TEST_F(DocumentLoaderTest, ClientPendingRequestCompletePartialAndFullLoader) {
+  MockClient client;
+  client.SetCanUsePartialLoading();
+  DocumentLoader loader(&client);
+  loader.Init(client.CreateFullPageLoader(), "http://url.com");
+
+  EXPECT_CALL(client, OnPendingRequestComplete()).Times(1);
+  loader.RequestData(16 * DocumentLoader::kDefaultRequestSize + 4000, 4000);
+  loader.RequestData(4 * DocumentLoader::kDefaultRequestSize + 4000, 4000);
+
+  for (int i = 0; i < 5; ++i) {
+    client.full_page_loader_data()->CallReadCallback(
+        DocumentLoader::kDefaultRequestSize);
+  }
+
+  Mock::VerifyAndClear(&client);
+
+  EXPECT_CALL(client, OnPendingRequestComplete()).Times(1);
+  client.SendAllPartialData();
+  Mock::VerifyAndClear(&client);
+}
+
+}  // namespace chrome_pdf