Fix some nits in pdf DocumentLoader code.

And add a header to IWYU in PDFiumEngine.

Change-Id: I93198a22d80d252339f19328788ac2e6ec5a96f9
Reviewed-on: https://chromium-review.googlesource.com/939643
Reviewed-by: dsinclair <dsinclair@chromium.org>
Commit-Queue: Lei Zhang <thestig@chromium.org>
Cr-Commit-Position: refs/heads/master@{#539515}

pdf/document_loader.cc

@@ -9,6 +9,7 @@
 
 #include <algorithm>
 #include <memory>
+#include <utility>
 
 #include "base/logging.h"
 #include "base/numerics/safe_math.h"
@@ -52,8 +53,6 @@ bool IsValidContentType(const std::string& type) {
 
 }  // namespace
 
-DocumentLoader::Client::~Client() = default;
-
 DocumentLoader::Chunk::Chunk() = default;
 
 DocumentLoader::Chunk::~Chunk() = default;

pdf/document_loader.h

@@ -8,15 +8,16 @@
 #include <stddef.h>
 #include <stdint.h>
 
-#include <list>
 #include <memory>
 #include <string>
-#include <utility>
-#include <vector>
 
 #include "pdf/chunk_stream.h"
 #include "ppapi/utility/completion_callback_factory.h"
 
+namespace pp {
+class Instance;
+}
+
 namespace chrome_pdf {
 
 class URLLoaderWrapper;
@@ -28,7 +29,7 @@ class DocumentLoader {
 
   class Client {
    public:
-    virtual ~Client();
+    virtual ~Client() = default;
 
     // Gets the pp::Instance object.
     virtual pp::Instance* GetPluginInstance() = 0;
@@ -51,13 +52,13 @@ class DocumentLoader {
 
   bool Init(std::unique_ptr<URLLoaderWrapper> loader, const std::string& url);
 
-  // Data access interface. Return true is successful.
+  // Data access interface. Return true if successful.
   bool GetBlock(uint32_t position, uint32_t size, void* buf) const;
 
-  // Data availability interface. Return true data available.
+  // Data availability interface. Return true if data is available.
   bool IsDataAvailable(uint32_t position, uint32_t size) const;
 
-  // Data availability interface. Return true data available.
+  // Data request interface.
   void RequestData(uint32_t position, uint32_t size);
 
   bool IsDocumentComplete() const;
@@ -67,8 +68,8 @@ class DocumentLoader {
   // Clear pending requests from the queue.
   void ClearPendingRequests();
 
+  // Exposed for unit tests.
   void SetPartialLoadingEnabled(bool enabled);
-
   bool is_partial_loader_active() const { return is_partial_loader_active_; }
 
  private:

pdf/document_loader_unittest.cc

@@ -7,6 +7,7 @@
 #include <algorithm>
 #include <memory>
 #include <string>
+#include <vector>
 
 #include "base/logging.h"
 #include "pdf/url_loader_wrapper.h"
@@ -24,6 +25,8 @@ namespace chrome_pdf {
 
 namespace {
 
+constexpr uint32_t kDefaultRequestSize = DocumentLoader::kDefaultRequestSize;
+
 class TestURLLoader : public URLLoaderWrapper {
  public:
   class LoaderData {
@@ -228,7 +231,7 @@ class TestClient : public DocumentLoader::Client {
     partial_loader_data_.CallOpenCallback(0);
     uint32_t length = partial_loader_data_.byte_range().length();
     while (length > 0) {
-      const uint32_t max_part_len = DocumentLoader::kDefaultRequestSize;
+      const uint32_t max_part_len = kDefaultRequestSize;
       const uint32_t part_len = std::min(length, max_part_len);
       partial_loader_data_.CallReadCallback(part_len);
       length -= part_len;
@@ -270,23 +273,20 @@ TEST_F(DocumentLoaderTest, PartialLoadingEnabled) {
   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);
+  client.full_page_loader_data()->CallReadCallback(kDefaultRequestSize);
   EXPECT_TRUE(loader.is_partial_loader_active());
 }
 
 TEST_F(DocumentLoaderTest, PartialLoadingDisabledOnSmallFiles) {
   TestClient client;
   client.SetCanUsePartialLoading();
-  client.full_page_loader_data()->set_content_length(
-      DocumentLoader::kDefaultRequestSize * 2);
+  client.full_page_loader_data()->set_content_length(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);
+  client.full_page_loader_data()->CallReadCallback(kDefaultRequestSize);
   EXPECT_FALSE(loader.is_partial_loader_active());
 }
 
@@ -299,8 +299,7 @@ TEST_F(DocumentLoaderTest, PartialLoadingDisabledIfContentEncoded) {
   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);
+  client.full_page_loader_data()->CallReadCallback(kDefaultRequestSize);
   EXPECT_FALSE(loader.is_partial_loader_active());
 }
 
@@ -313,8 +312,7 @@ TEST_F(DocumentLoaderTest, PartialLoadingDisabledNoAcceptRangeBytes) {
   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);
+  client.full_page_loader_data()->CallReadCallback(kDefaultRequestSize);
   EXPECT_FALSE(loader.is_partial_loader_active());
 }
 
@@ -326,11 +324,10 @@ TEST_F(DocumentLoaderTest, PartialLoadingReallyDisabledRequestFromBegin) {
   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);
+  loader.RequestData(kDefaultRequestSize, 1);
   EXPECT_FALSE(loader.is_partial_loader_active());
   // Always send initial data from FullPageLoader.
-  client.full_page_loader_data()->CallReadCallback(
-      DocumentLoader::kDefaultRequestSize);
+  client.full_page_loader_data()->CallReadCallback(kDefaultRequestSize);
   EXPECT_FALSE(loader.is_partial_loader_active());
 }
 
@@ -343,8 +340,7 @@ TEST_F(DocumentLoaderTest, PartialLoadingReallyDisabledRequestFromMiddle) {
   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);
+  client.full_page_loader_data()->CallReadCallback(kDefaultRequestSize);
   EXPECT_FALSE(loader.is_partial_loader_active());
 }
 
@@ -364,8 +360,7 @@ TEST_F(DocumentLoaderTest, PartialLoadingSimple) {
   EXPECT_FALSE(loader.is_partial_loader_active());
 
   // Always send initial data from FullPageLoader.
-  client.full_page_loader_data()->CallReadCallback(
-      DocumentLoader::kDefaultRequestSize);
+  client.full_page_loader_data()->CallReadCallback(kDefaultRequestSize);
 
   // Partial loader should request headers.
   EXPECT_TRUE(client.partial_loader_data()->IsWaitOpen());
@@ -393,8 +388,7 @@ TEST_F(DocumentLoaderTest, PartialLoadingBackOrder) {
   EXPECT_FALSE(loader.is_partial_loader_active());
 
   // Always send initial data from FullPageLoader.
-  client.full_page_loader_data()->CallReadCallback(
-      DocumentLoader::kDefaultRequestSize);
+  client.full_page_loader_data()->CallReadCallback(kDefaultRequestSize);
 
   // Partial loader should request headers.
   EXPECT_TRUE(client.partial_loader_data()->IsWaitOpen());
@@ -452,19 +446,16 @@ TEST_F(DocumentLoaderTest, CompleteNoContentLength) {
 TEST_F(DocumentLoaderTest, CompleteWithPartial) {
   TestClient client;
   client.SetCanUsePartialLoading();
-  client.full_page_loader_data()->set_content_length(
-      DocumentLoader::kDefaultRequestSize * 20);
+  client.full_page_loader_data()->set_content_length(kDefaultRequestSize * 20);
   DocumentLoader loader(&client);
   loader.Init(client.CreateFullPageLoader(), "http://url.com");
-  loader.RequestData(19 * DocumentLoader::kDefaultRequestSize,
-                     DocumentLoader::kDefaultRequestSize);
+  loader.RequestData(19 * kDefaultRequestSize, 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);
+  client.full_page_loader_data()->CallReadCallback(kDefaultRequestSize);
   EXPECT_TRUE(client.full_page_loader_data()->closed());
   EXPECT_FALSE(client.partial_loader_data()->closed());
 
@@ -479,15 +470,14 @@ TEST_F(DocumentLoaderTest, PartialRequestLastChunk) {
   const uint32_t kLastChunkSize = 300;
   TestClient client;
   client.SetCanUsePartialLoading();
-  client.full_page_loader_data()->set_content_length(
-      DocumentLoader::kDefaultRequestSize * 20 + kLastChunkSize);
+  client.full_page_loader_data()->set_content_length(kDefaultRequestSize * 20 +
+                                                     kLastChunkSize);
   DocumentLoader loader(&client);
   loader.Init(client.CreateFullPageLoader(), "http://url.com");
-  loader.RequestData(20 * DocumentLoader::kDefaultRequestSize, 1);
+  loader.RequestData(20 * kDefaultRequestSize, 1);
 
   // Always send initial data from FullPageLoader.
-  client.full_page_loader_data()->CallReadCallback(
-      DocumentLoader::kDefaultRequestSize);
+  client.full_page_loader_data()->CallReadCallback(kDefaultRequestSize);
 
   EXPECT_TRUE(client.partial_loader_data()->IsWaitOpen());
   EXPECT_EQ(
@@ -497,15 +487,13 @@ TEST_F(DocumentLoaderTest, PartialRequestLastChunk) {
       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;
+  while (data_length > kDefaultRequestSize) {
+    client.partial_loader_data()->CallReadCallback(kDefaultRequestSize);
+    data_length -= kDefaultRequestSize;
   }
   EXPECT_EQ(kLastChunkSize, data_length);
   client.partial_loader_data()->CallReadCallback(kLastChunkSize);
-  EXPECT_TRUE(loader.IsDataAvailable(DocumentLoader::kDefaultRequestSize * 20,
-                                     kLastChunkSize));
+  EXPECT_TRUE(loader.IsDataAvailable(kDefaultRequestSize * 20, kLastChunkSize));
 }
 
 TEST_F(DocumentLoaderTest, DocumentSize) {
@@ -523,38 +511,35 @@ TEST_F(DocumentLoaderTest, DocumentSizeNoContentLength) {
   DocumentLoader loader(&client);
   loader.Init(client.CreateFullPageLoader(), "http://url.com");
   EXPECT_EQ(0ul, loader.GetDocumentSize());
-  client.full_page_loader_data()->CallReadCallback(
-      DocumentLoader::kDefaultRequestSize);
+  client.full_page_loader_data()->CallReadCallback(kDefaultRequestSize);
   client.full_page_loader_data()->CallReadCallback(1000);
   client.full_page_loader_data()->CallReadCallback(500);
   client.full_page_loader_data()->CallReadCallback(0);
-  EXPECT_EQ(DocumentLoader::kDefaultRequestSize + 1000ul + 500ul,
-            loader.GetDocumentSize());
+  EXPECT_EQ(kDefaultRequestSize + 1000ul + 500ul, loader.GetDocumentSize());
   EXPECT_TRUE(loader.IsDocumentComplete());
 }
 
 TEST_F(DocumentLoaderTest, ClearPendingRequests) {
   TestClient client;
   client.SetCanUsePartialLoading();
-  client.full_page_loader_data()->set_content_length(
-      DocumentLoader::kDefaultRequestSize * 100 + 58383);
+  client.full_page_loader_data()->set_content_length(kDefaultRequestSize * 100 +
+                                                     58383);
   DocumentLoader loader(&client);
   loader.Init(client.CreateFullPageLoader(), "http://url.com");
-  loader.RequestData(17 * DocumentLoader::kDefaultRequestSize + 100, 10);
+  loader.RequestData(17 * kDefaultRequestSize + 100, 10);
   loader.ClearPendingRequests();
-  loader.RequestData(15 * DocumentLoader::kDefaultRequestSize + 200, 20);
+  loader.RequestData(15 * 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);
+  client.full_page_loader_data()->CallReadCallback(kDefaultRequestSize);
 
   {
     EXPECT_TRUE(client.partial_loader_data()->IsWaitOpen());
-    const gfx::Range range_requested(15 * DocumentLoader::kDefaultRequestSize,
-                                     16 * DocumentLoader::kDefaultRequestSize);
+    const gfx::Range range_requested(15 * kDefaultRequestSize,
+                                     16 * kDefaultRequestSize);
     EXPECT_EQ(range_requested.start(),
               client.partial_loader_data()->open_byte_range().start());
     EXPECT_LE(range_requested.end(),
@@ -567,33 +552,30 @@ TEST_F(DocumentLoaderTest, 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);
+  client.partial_loader_data()->CallReadCallback(kDefaultRequestSize);
   EXPECT_FALSE(client.partial_loader_data()->closed());
   // Current request should continue loading, because no other request queued.
 
-  loader.RequestData(18 * DocumentLoader::kDefaultRequestSize + 200, 20);
+  loader.RequestData(18 * kDefaultRequestSize + 200, 20);
   // Requests queue is processed only on receiving data.
-  client.partial_loader_data()->CallReadCallback(
-      DocumentLoader::kDefaultRequestSize);
+  client.partial_loader_data()->CallReadCallback(kDefaultRequestSize);
   // New request within close distance from the one currently loading. Loading
   // isn't 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);
+  loader.RequestData(60 * kDefaultRequestSize + 100, 10);
+  loader.RequestData(35 * kDefaultRequestSize + 200, 20);
   // Requests queue is processed only on receiving data.
-  client.partial_loader_data()->CallReadCallback(
-      DocumentLoader::kDefaultRequestSize);
+  client.partial_loader_data()->CallReadCallback(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);
+    const gfx::Range range_requested(35 * kDefaultRequestSize,
+                                     36 * kDefaultRequestSize);
     EXPECT_EQ(range_requested.start(),
               client.partial_loader_data()->open_byte_range().start());
     EXPECT_LE(range_requested.end(),
@@ -605,18 +587,17 @@ TEST_F(DocumentLoaderTest, ClearPendingRequests) {
   client.partial_loader_data()->CallOpenCallback(0);
   // Override pending requests.
   loader.ClearPendingRequests();
-  loader.RequestData(70 * DocumentLoader::kDefaultRequestSize + 100, 10);
+  loader.RequestData(70 * kDefaultRequestSize + 100, 10);
 
   // Requests queue is processed only on receiving data.
-  client.partial_loader_data()->CallReadCallback(
-      DocumentLoader::kDefaultRequestSize);
+  client.partial_loader_data()->CallReadCallback(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);
+    const gfx::Range range_requested(70 * kDefaultRequestSize,
+                                     71 * kDefaultRequestSize);
     EXPECT_EQ(range_requested.start(),
               client.partial_loader_data()->open_byte_range().start());
     EXPECT_LE(range_requested.end(),
@@ -628,91 +609,74 @@ TEST_F(DocumentLoaderTest, ClearPendingRequests) {
 }
 
 TEST_F(DocumentLoaderTest, GetBlock) {
-  std::vector<char> buffer(DocumentLoader::kDefaultRequestSize);
+  std::vector<char> buffer(kDefaultRequestSize);
   TestClient client;
   client.SetCanUsePartialLoading();
-  client.full_page_loader_data()->set_content_length(
-      DocumentLoader::kDefaultRequestSize * 20 + 58383);
+  client.full_page_loader_data()->set_content_length(kDefaultRequestSize * 20 +
+                                                     58383);
   DocumentLoader loader(&client);
   loader.Init(client.CreateFullPageLoader(), "http://url.com");
   EXPECT_FALSE(loader.GetBlock(0, 1000, buffer.data()));
-  client.full_page_loader_data()->CallReadCallback(
-      DocumentLoader::kDefaultRequestSize);
+  client.full_page_loader_data()->CallReadCallback(kDefaultRequestSize);
   EXPECT_TRUE(loader.GetBlock(0, 1000, buffer.data()));
-  EXPECT_FALSE(loader.GetBlock(DocumentLoader::kDefaultRequestSize, 1500,
-                               buffer.data()));
-  client.full_page_loader_data()->CallReadCallback(
-      DocumentLoader::kDefaultRequestSize);
-  EXPECT_TRUE(loader.GetBlock(DocumentLoader::kDefaultRequestSize, 1500,
-                              buffer.data()));
+  EXPECT_FALSE(loader.GetBlock(kDefaultRequestSize, 1500, buffer.data()));
+  client.full_page_loader_data()->CallReadCallback(kDefaultRequestSize);
+  EXPECT_TRUE(loader.GetBlock(kDefaultRequestSize, 1500, buffer.data()));
 
-  EXPECT_FALSE(loader.GetBlock(17 * DocumentLoader::kDefaultRequestSize, 3000,
-                               buffer.data()));
-  loader.RequestData(17 * DocumentLoader::kDefaultRequestSize + 100, 10);
-  EXPECT_FALSE(loader.GetBlock(17 * DocumentLoader::kDefaultRequestSize, 3000,
-                               buffer.data()));
+  EXPECT_FALSE(loader.GetBlock(17 * kDefaultRequestSize, 3000, buffer.data()));
+  loader.RequestData(17 * kDefaultRequestSize + 100, 10);
+  EXPECT_FALSE(loader.GetBlock(17 * kDefaultRequestSize, 3000, buffer.data()));
 
   // Requests queue is processed only on receiving data.
-  client.full_page_loader_data()->CallReadCallback(
-      DocumentLoader::kDefaultRequestSize);
+  client.full_page_loader_data()->CallReadCallback(kDefaultRequestSize);
 
   client.SendAllPartialData();
-  EXPECT_TRUE(loader.GetBlock(17 * DocumentLoader::kDefaultRequestSize, 3000,
-                              buffer.data()));
+  EXPECT_TRUE(loader.GetBlock(17 * kDefaultRequestSize, 3000, buffer.data()));
 }
 
 TEST_F(DocumentLoaderTest, IsDataAvailable) {
   TestClient client;
   client.SetCanUsePartialLoading();
-  client.full_page_loader_data()->set_content_length(
-      DocumentLoader::kDefaultRequestSize * 20 + 58383);
+  client.full_page_loader_data()->set_content_length(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);
+  client.full_page_loader_data()->CallReadCallback(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(kDefaultRequestSize, 1500));
+  client.full_page_loader_data()->CallReadCallback(kDefaultRequestSize);
+  EXPECT_TRUE(loader.IsDataAvailable(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));
+  EXPECT_FALSE(loader.IsDataAvailable(17 * kDefaultRequestSize, 3000));
+  loader.RequestData(17 * kDefaultRequestSize + 100, 10);
+  EXPECT_FALSE(loader.IsDataAvailable(17 * kDefaultRequestSize, 3000));
 
   // Requests queue is processed only on receiving data.
-  client.full_page_loader_data()->CallReadCallback(
-      DocumentLoader::kDefaultRequestSize);
+  client.full_page_loader_data()->CallReadCallback(kDefaultRequestSize);
 
   client.SendAllPartialData();
-  EXPECT_TRUE(
-      loader.IsDataAvailable(17 * DocumentLoader::kDefaultRequestSize, 3000));
+  EXPECT_TRUE(loader.IsDataAvailable(17 * kDefaultRequestSize, 3000));
 }
 
 TEST_F(DocumentLoaderTest, RequestData) {
   TestClient client;
   client.SetCanUsePartialLoading();
-  client.full_page_loader_data()->set_content_length(
-      DocumentLoader::kDefaultRequestSize * 100 + 58383);
+  client.full_page_loader_data()->set_content_length(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);
+  loader.RequestData(37 * kDefaultRequestSize + 200, 10);
+  loader.RequestData(25 * kDefaultRequestSize + 600, 100);
+  loader.RequestData(13 * kDefaultRequestSize + 900, 500);
 
   // Send initial data from FullPageLoader.
-  client.full_page_loader_data()->CallReadCallback(
-      DocumentLoader::kDefaultRequestSize);
+  client.full_page_loader_data()->CallReadCallback(kDefaultRequestSize);
 
   {
     EXPECT_TRUE(client.partial_loader_data()->IsWaitOpen());
-    const gfx::Range range_requested(13 * DocumentLoader::kDefaultRequestSize,
-                                     14 * DocumentLoader::kDefaultRequestSize);
+    const gfx::Range range_requested(13 * kDefaultRequestSize,
+                                     14 * kDefaultRequestSize);
     EXPECT_EQ(range_requested.start(),
               client.partial_loader_data()->open_byte_range().start());
     EXPECT_LE(range_requested.end(),
@@ -723,15 +687,14 @@ TEST_F(DocumentLoaderTest, RequestData) {
   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);
+  loader.RequestData(38 * kDefaultRequestSize + 200, 10);
+  loader.RequestData(26 * kDefaultRequestSize + 600, 100);
   // Requests queue is processed only on receiving data.
-  client.partial_loader_data()->CallReadCallback(
-      DocumentLoader::kDefaultRequestSize);
+  client.partial_loader_data()->CallReadCallback(kDefaultRequestSize);
   {
     EXPECT_TRUE(client.partial_loader_data()->IsWaitOpen());
-    const gfx::Range range_requested(26 * DocumentLoader::kDefaultRequestSize,
-                                     27 * DocumentLoader::kDefaultRequestSize);
+    const gfx::Range range_requested(26 * kDefaultRequestSize,
+                                     27 * kDefaultRequestSize);
     EXPECT_EQ(range_requested.start(),
               client.partial_loader_data()->open_byte_range().start());
     EXPECT_LE(range_requested.end(),
@@ -742,14 +705,13 @@ TEST_F(DocumentLoaderTest, RequestData) {
   client.partial_loader_data()->CallOpenCallback(0);
   // Override pending requests.
   loader.ClearPendingRequests();
-  loader.RequestData(39 * DocumentLoader::kDefaultRequestSize + 200, 10);
+  loader.RequestData(39 * kDefaultRequestSize + 200, 10);
   // Requests queue is processed only on receiving data.
-  client.partial_loader_data()->CallReadCallback(
-      DocumentLoader::kDefaultRequestSize);
+  client.partial_loader_data()->CallReadCallback(kDefaultRequestSize);
   {
     EXPECT_TRUE(client.partial_loader_data()->IsWaitOpen());
-    const gfx::Range range_requested(39 * DocumentLoader::kDefaultRequestSize,
-                                     40 * DocumentLoader::kDefaultRequestSize);
+    const gfx::Range range_requested(39 * kDefaultRequestSize,
+                                     40 * kDefaultRequestSize);
     EXPECT_EQ(range_requested.start(),
               client.partial_loader_data()->open_byte_range().start());
     EXPECT_LE(range_requested.end(),
@@ -767,23 +729,20 @@ TEST_F(DocumentLoaderTest, RequestData) {
 TEST_F(DocumentLoaderTest, DoNotLoadAvailablePartialData) {
   TestClient client;
   client.SetCanUsePartialLoading();
-  client.full_page_loader_data()->set_content_length(
-      DocumentLoader::kDefaultRequestSize * 20 + 58383);
+  client.full_page_loader_data()->set_content_length(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);
+  client.full_page_loader_data()->CallReadCallback(kDefaultRequestSize);
 
   // Send more data from FullPageLoader.
-  client.full_page_loader_data()->CallReadCallback(
-      DocumentLoader::kDefaultRequestSize);
+  client.full_page_loader_data()->CallReadCallback(kDefaultRequestSize);
 
-  loader.RequestData(2 * DocumentLoader::kDefaultRequestSize + 200, 10);
+  loader.RequestData(2 * kDefaultRequestSize + 200, 10);
 
   // Send more data from FullPageLoader.
-  client.full_page_loader_data()->CallReadCallback(
-      DocumentLoader::kDefaultRequestSize);
+  client.full_page_loader_data()->CallReadCallback(kDefaultRequestSize);
 
   // Partial loading should not have started for already available data.
   EXPECT_TRUE(client.partial_loader_data()->closed());
@@ -792,19 +751,17 @@ TEST_F(DocumentLoaderTest, DoNotLoadAvailablePartialData) {
 TEST_F(DocumentLoaderTest, DoNotLoadDataAfterComplete) {
   TestClient client;
   client.SetCanUsePartialLoading();
-  client.full_page_loader_data()->set_content_length(
-      DocumentLoader::kDefaultRequestSize * 20);
+  client.full_page_loader_data()->set_content_length(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);
+    client.full_page_loader_data()->CallReadCallback(kDefaultRequestSize);
   }
 
   EXPECT_TRUE(loader.IsDocumentComplete());
 
-  loader.RequestData(17 * DocumentLoader::kDefaultRequestSize + 200, 10);
+  loader.RequestData(17 * kDefaultRequestSize + 200, 10);
 
   EXPECT_TRUE(client.partial_loader_data()->closed());
   EXPECT_TRUE(client.full_page_loader_data()->closed());
@@ -813,16 +770,14 @@ TEST_F(DocumentLoaderTest, DoNotLoadDataAfterComplete) {
 TEST_F(DocumentLoaderTest, DoNotLoadPartialDataAboveDocumentSize) {
   TestClient client;
   client.SetCanUsePartialLoading();
-  client.full_page_loader_data()->set_content_length(
-      DocumentLoader::kDefaultRequestSize * 20);
+  client.full_page_loader_data()->set_content_length(kDefaultRequestSize * 20);
   DocumentLoader loader(&client);
   loader.Init(client.CreateFullPageLoader(), "http://url.com");
 
-  loader.RequestData(20 * DocumentLoader::kDefaultRequestSize + 200, 10);
+  loader.RequestData(20 * kDefaultRequestSize + 200, 10);
 
   // Send initial data from FullPageLoader.
-  client.full_page_loader_data()->CallReadCallback(
-      DocumentLoader::kDefaultRequestSize);
+  client.full_page_loader_data()->CallReadCallback(kDefaultRequestSize);
 
   EXPECT_TRUE(client.partial_loader_data()->closed());
 }
@@ -830,19 +785,18 @@ TEST_F(DocumentLoaderTest, DoNotLoadPartialDataAboveDocumentSize) {
 TEST_F(DocumentLoaderTest, MergePendingRequests) {
   TestClient client;
   client.SetCanUsePartialLoading();
-  client.full_page_loader_data()->set_content_length(
-      DocumentLoader::kDefaultRequestSize * 50 + 58383);
+  client.full_page_loader_data()->set_content_length(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);
+  loader.RequestData(17 * kDefaultRequestSize + 200, 10);
+  loader.RequestData(16 * kDefaultRequestSize + 600, 100);
 
   // Send initial data from FullPageLoader.
-  client.full_page_loader_data()->CallReadCallback(
-      DocumentLoader::kDefaultRequestSize);
+  client.full_page_loader_data()->CallReadCallback(kDefaultRequestSize);
 
-  const gfx::Range range_requested(16 * DocumentLoader::kDefaultRequestSize,
-                                   18 * DocumentLoader::kDefaultRequestSize);
+  const gfx::Range range_requested(16 * kDefaultRequestSize,
+                                   18 * kDefaultRequestSize);
   EXPECT_EQ(range_requested.start(),
             client.partial_loader_data()->open_byte_range().start());
   EXPECT_LE(range_requested.end(),
@@ -860,16 +814,14 @@ TEST_F(DocumentLoaderTest, MergePendingRequests) {
 TEST_F(DocumentLoaderTest, PartialStopOnStatusCodeError) {
   TestClient client;
   client.SetCanUsePartialLoading();
-  client.full_page_loader_data()->set_content_length(
-      DocumentLoader::kDefaultRequestSize * 20);
+  client.full_page_loader_data()->set_content_length(kDefaultRequestSize * 20);
   DocumentLoader loader(&client);
   loader.Init(client.CreateFullPageLoader(), "http://url.com");
 
-  loader.RequestData(17 * DocumentLoader::kDefaultRequestSize + 200, 10);
+  loader.RequestData(17 * kDefaultRequestSize + 200, 10);
 
   // Send initial data from FullPageLoader.
-  client.full_page_loader_data()->CallReadCallback(
-      DocumentLoader::kDefaultRequestSize);
+  client.full_page_loader_data()->CallReadCallback(kDefaultRequestSize);
 
   EXPECT_TRUE(client.partial_loader_data()->IsWaitOpen());
   client.partial_loader_data()->set_status_code(404);
@@ -881,16 +833,14 @@ TEST_F(DocumentLoaderTest,
        PartialAsFullDocumentLoadingRangeRequestNoRangeField) {
   TestClient client;
   client.SetCanUsePartialLoading();
-  client.full_page_loader_data()->set_content_length(
-      DocumentLoader::kDefaultRequestSize * 20);
+  client.full_page_loader_data()->set_content_length(kDefaultRequestSize * 20);
   DocumentLoader loader(&client);
   loader.Init(client.CreateFullPageLoader(), "http://url.com");
 
-  loader.RequestData(17 * DocumentLoader::kDefaultRequestSize + 200, 10);
+  loader.RequestData(17 * kDefaultRequestSize + 200, 10);
 
   // Send initial data from FullPageLoader.
-  client.full_page_loader_data()->CallReadCallback(
-      DocumentLoader::kDefaultRequestSize);
+  client.full_page_loader_data()->CallReadCallback(kDefaultRequestSize);
 
   EXPECT_TRUE(client.partial_loader_data()->IsWaitOpen());
   client.partial_loader_data()->set_byte_range(gfx::Range::InvalidRange());
@@ -903,74 +853,65 @@ TEST_F(DocumentLoaderTest,
 TEST_F(DocumentLoaderTest, PartialMultiPart) {
   TestClient client;
   client.SetCanUsePartialLoading();
-  client.full_page_loader_data()->set_content_length(
-      DocumentLoader::kDefaultRequestSize * 20);
+  client.full_page_loader_data()->set_content_length(kDefaultRequestSize * 20);
   DocumentLoader loader(&client);
   loader.Init(client.CreateFullPageLoader(), "http://url.com");
 
-  loader.RequestData(17 * DocumentLoader::kDefaultRequestSize + 200, 10);
+  loader.RequestData(17 * kDefaultRequestSize + 200, 10);
 
   // Send initial data from FullPageLoader.
-  client.full_page_loader_data()->CallReadCallback(
-      DocumentLoader::kDefaultRequestSize);
+  client.full_page_loader_data()->CallReadCallback(kDefaultRequestSize);
 
   EXPECT_TRUE(client.partial_loader_data()->IsWaitOpen());
   client.partial_loader_data()->set_is_multipart(true);
   client.partial_loader_data()->CallOpenCallback(0);
   client.partial_loader_data()->set_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));
+      gfx::Range(17 * kDefaultRequestSize, 18 * kDefaultRequestSize));
+  client.partial_loader_data()->CallReadCallback(kDefaultRequestSize);
+  EXPECT_TRUE(
+      loader.IsDataAvailable(17 * kDefaultRequestSize, kDefaultRequestSize));
 }
 
 TEST_F(DocumentLoaderTest, PartialMultiPartRangeError) {
   TestClient client;
   client.SetCanUsePartialLoading();
-  client.full_page_loader_data()->set_content_length(
-      DocumentLoader::kDefaultRequestSize * 20);
+  client.full_page_loader_data()->set_content_length(kDefaultRequestSize * 20);
   DocumentLoader loader(&client);
   loader.Init(client.CreateFullPageLoader(), "http://url.com");
 
-  loader.RequestData(17 * DocumentLoader::kDefaultRequestSize + 200, 10);
+  loader.RequestData(17 * kDefaultRequestSize + 200, 10);
 
   // Send initial data from FullPageLoader.
-  client.full_page_loader_data()->CallReadCallback(
-      DocumentLoader::kDefaultRequestSize);
+  client.full_page_loader_data()->CallReadCallback(kDefaultRequestSize);
 
   EXPECT_TRUE(client.partial_loader_data()->IsWaitOpen());
   client.partial_loader_data()->set_is_multipart(true);
   client.partial_loader_data()->CallOpenCallback(0);
   client.partial_loader_data()->set_byte_range(gfx::Range::InvalidRange());
-  client.partial_loader_data()->CallReadCallback(
-      DocumentLoader::kDefaultRequestSize);
-  EXPECT_FALSE(loader.IsDataAvailable(17 * DocumentLoader::kDefaultRequestSize,
-                                      DocumentLoader::kDefaultRequestSize));
+  client.partial_loader_data()->CallReadCallback(kDefaultRequestSize);
+  EXPECT_FALSE(
+      loader.IsDataAvailable(17 * kDefaultRequestSize, kDefaultRequestSize));
   EXPECT_TRUE(client.partial_loader_data()->closed());
 }
 
 TEST_F(DocumentLoaderTest, PartialConnectionErrorOnOpen) {
   TestClient client;
   client.SetCanUsePartialLoading();
-  client.full_page_loader_data()->set_content_length(
-      DocumentLoader::kDefaultRequestSize * 20);
+  client.full_page_loader_data()->set_content_length(kDefaultRequestSize * 20);
   DocumentLoader loader(&client);
   loader.Init(client.CreateFullPageLoader(), "http://url.com");
 
-  loader.RequestData(17 * DocumentLoader::kDefaultRequestSize + 200, 10);
+  loader.RequestData(17 * kDefaultRequestSize + 200, 10);
 
   // Send initial data from FullPageLoader.
-  client.full_page_loader_data()->CallReadCallback(
-      DocumentLoader::kDefaultRequestSize);
+  client.full_page_loader_data()->CallReadCallback(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);
+  loader.RequestData(18 * kDefaultRequestSize + 200, 10);
 
   EXPECT_FALSE(client.partial_loader_data()->IsWaitOpen());
   EXPECT_TRUE(client.partial_loader_data()->closed());
@@ -979,28 +920,25 @@ TEST_F(DocumentLoaderTest, PartialConnectionErrorOnOpen) {
 TEST_F(DocumentLoaderTest, PartialConnectionErrorOnRead) {
   TestClient client;
   client.SetCanUsePartialLoading();
-  client.full_page_loader_data()->set_content_length(
-      DocumentLoader::kDefaultRequestSize * 20);
+  client.full_page_loader_data()->set_content_length(kDefaultRequestSize * 20);
   DocumentLoader loader(&client);
   loader.Init(client.CreateFullPageLoader(), "http://url.com");
 
-  loader.RequestData(17 * DocumentLoader::kDefaultRequestSize + 200, 10);
+  loader.RequestData(17 * kDefaultRequestSize + 200, 10);
 
   // Send initial data from FullPageLoader.
-  client.full_page_loader_data()->CallReadCallback(
-      DocumentLoader::kDefaultRequestSize);
+  client.full_page_loader_data()->CallReadCallback(kDefaultRequestSize);
 
   EXPECT_TRUE(client.partial_loader_data()->IsWaitOpen());
   client.partial_loader_data()->set_byte_range(
-      gfx::Range(17 * DocumentLoader::kDefaultRequestSize,
-                 18 * DocumentLoader::kDefaultRequestSize));
+      gfx::Range(17 * kDefaultRequestSize, 18 * 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);
+  loader.RequestData(18 * kDefaultRequestSize + 200, 10);
 
   EXPECT_FALSE(client.partial_loader_data()->IsWaitOpen());
   EXPECT_TRUE(client.partial_loader_data()->closed());
@@ -1009,21 +947,17 @@ TEST_F(DocumentLoaderTest, PartialConnectionErrorOnRead) {
 TEST_F(DocumentLoaderTest, ClientCompleteCallbacks) {
   MockClient client;
   client.SetCanUsePartialLoading();
-  client.full_page_loader_data()->set_content_length(
-      DocumentLoader::kDefaultRequestSize * 20);
+  client.full_page_loader_data()->set_content_length(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);
-  }
+  for (int i = 0; i < 19; ++i)
+    client.full_page_loader_data()->CallReadCallback(kDefaultRequestSize);
   Mock::VerifyAndClear(&client);
 
   EXPECT_CALL(client, OnDocumentComplete()).Times(1);
-  client.full_page_loader_data()->CallReadCallback(
-      DocumentLoader::kDefaultRequestSize);
+  client.full_page_loader_data()->CallReadCallback(kDefaultRequestSize);
   Mock::VerifyAndClear(&client);
 }
 
@@ -1034,10 +968,8 @@ TEST_F(DocumentLoaderTest, ClientCompleteCallbacksNoContentLength) {
 
   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);
-  }
+  for (int i = 0; i < 20; ++i)
+    client.full_page_loader_data()->CallReadCallback(kDefaultRequestSize);
   Mock::VerifyAndClear(&client);
 
   EXPECT_CALL(client, OnDocumentCanceled()).Times(0);
@@ -1049,17 +981,14 @@ TEST_F(DocumentLoaderTest, ClientCompleteCallbacksNoContentLength) {
 TEST_F(DocumentLoaderTest, ClientCancelCallback) {
   MockClient client;
   client.SetCanUsePartialLoading();
-  client.full_page_loader_data()->set_content_length(
-      DocumentLoader::kDefaultRequestSize * 20);
+  client.full_page_loader_data()->set_content_length(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);
-  }
+  for (int i = 0; i < 10; ++i)
+    client.full_page_loader_data()->CallReadCallback(kDefaultRequestSize);
   Mock::VerifyAndClear(&client);
 
   EXPECT_CALL(client, OnDocumentComplete()).Times(0);
@@ -1071,19 +1000,16 @@ TEST_F(DocumentLoaderTest, ClientCancelCallback) {
 TEST_F(DocumentLoaderTest, NewDataAvailable) {
   MockClient client;
   client.SetCanUsePartialLoading();
-  client.full_page_loader_data()->set_content_length(
-      DocumentLoader::kDefaultRequestSize * 20);
+  client.full_page_loader_data()->set_content_length(kDefaultRequestSize * 20);
   DocumentLoader loader(&client);
   loader.Init(client.CreateFullPageLoader(), "http://url.com");
 
   EXPECT_CALL(client, OnNewDataReceived()).Times(1);
-  client.full_page_loader_data()->CallReadCallback(
-      DocumentLoader::kDefaultRequestSize);
+  client.full_page_loader_data()->CallReadCallback(kDefaultRequestSize);
   Mock::VerifyAndClear(&client);
 
   EXPECT_CALL(client, OnNewDataReceived()).Times(1);
-  client.full_page_loader_data()->CallReadCallback(
-      DocumentLoader::kDefaultRequestSize - 100);
+  client.full_page_loader_data()->CallReadCallback(kDefaultRequestSize - 100);
   Mock::VerifyAndClear(&client);
 
   EXPECT_CALL(client, OnNewDataReceived()).Times(1);
@@ -1100,8 +1026,7 @@ TEST_F(DocumentLoaderTest, ClientPendingRequestCompleteFullLoader) {
   loader.RequestData(1000, 4000);
 
   EXPECT_CALL(client, OnPendingRequestComplete()).Times(1);
-  client.full_page_loader_data()->CallReadCallback(
-      DocumentLoader::kDefaultRequestSize);
+  client.full_page_loader_data()->CallReadCallback(kDefaultRequestSize);
   Mock::VerifyAndClear(&client);
 }
 
@@ -1112,11 +1037,10 @@ TEST_F(DocumentLoaderTest, ClientPendingRequestCompletePartialLoader) {
   loader.Init(client.CreateFullPageLoader(), "http://url.com");
 
   EXPECT_CALL(client, OnPendingRequestComplete()).Times(1);
-  loader.RequestData(15 * DocumentLoader::kDefaultRequestSize + 4000, 4000);
+  loader.RequestData(15 * kDefaultRequestSize + 4000, 4000);
 
   // Always send initial data from FullPageLoader.
-  client.full_page_loader_data()->CallReadCallback(
-      DocumentLoader::kDefaultRequestSize);
+  client.full_page_loader_data()->CallReadCallback(kDefaultRequestSize);
 
   client.SendAllPartialData();
   Mock::VerifyAndClear(&client);
@@ -1129,13 +1053,11 @@ TEST_F(DocumentLoaderTest, ClientPendingRequestCompletePartialAndFullLoader) {
   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);
+  loader.RequestData(16 * kDefaultRequestSize + 4000, 4000);
+  loader.RequestData(4 * kDefaultRequestSize + 4000, 4000);
 
-  for (int i = 0; i < 5; ++i) {
-    client.full_page_loader_data()->CallReadCallback(
-        DocumentLoader::kDefaultRequestSize);
-  }
+  for (int i = 0; i < 5; ++i)
+    client.full_page_loader_data()->CallReadCallback(kDefaultRequestSize);
 
   Mock::VerifyAndClear(&client);
 

pdf/pdfium/pdfium_engine.h

@@ -27,6 +27,7 @@
 #include "ppapi/cpp/input_event.h"
 #include "ppapi/cpp/point.h"
 #include "ppapi/cpp/var_array.h"
+#include "ppapi/utility/completion_callback_factory.h"
 #include "third_party/pdfium/public/fpdf_dataavail.h"
 #include "third_party/pdfium/public/fpdf_formfill.h"
 #include "third_party/pdfium/public/fpdf_progressive.h"
@@ -637,8 +638,8 @@ class PDFiumEngine : public PDFEngine,
   std::string url_;
   std::string headers_;
   pp::CompletionCallbackFactory<PDFiumEngine> find_factory_;
-
   pp::CompletionCallbackFactory<PDFiumEngine> password_factory_;
+
   // Set to true if the user is being prompted for their password. Will be set
   // to false after the user finishes getting their password.
   bool getting_password_ = false;