Chromium Code Reviews
chromiumcodereview-hr@appspot.gserviceaccount.com (chromiumcodereview-hr) | Please choose your nickname with Settings | Help | Chromium Project | Gerrit Changes | Sign out
(361)

Issues Search
    My Issues | Starred     Open | Closed | All

Unified Diff: pdf/document_loader_unittest.cc

Issue 2349753003: Improve linearized pdf load/show time. (Closed)
Patch Set: Update tests.. Created 4 years, 2 months ago
Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.
Jump to:
View side-by-side diff with in-line comments
Download patch
« no previous file with comments | « pdf/document_loader.cc ('k') | pdf/out_of_process_instance.h » ('j') | no next file with comments »
Expand Comments ('e') | Collapse Comments ('c') | Show Comments Hide Comments ('s')
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..8fb38beedddcea4e2708b15c726f0e343b93c8fe
--- /dev/null
+++ b/pdf/document_loader_unittest.cc
@@ -0,0 +1,1121 @@
+// 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, PartialLoadingEnabled) {
+ TestClient client;
+ client.SetCanUsePartialLoading();
+ 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());
+}
+
+TEST_F(DocumentLoaderTest, PartialLoadingDisabledOnSmallFiles) {
+ TestClient client;
+ client.SetCanUsePartialLoading();
+ 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());
+}
+
+TEST_F(DocumentLoaderTest, PartialLoadingDisabledIfContentEncoded) {
+ TestClient client;
+ client.SetCanUsePartialLoading();
+ 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());
+}
+
+TEST_F(DocumentLoaderTest, PartialLoadingDisabledNoAcceptRangeBytes) {
+ TestClient client;
+ client.SetCanUsePartialLoading();
+ 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());
+}
+
+TEST_F(DocumentLoaderTest, PartialLoadingRealyDisabledRequestFromBegin) {
+ TestClient client;
+ DocumentLoader loader(&client);
+ client.SetCanUsePartialLoading();
+ 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());
+}
+
+TEST_F(DocumentLoaderTest, PartialLoadingRealyDisabledRequestFromMiddle) {
spelchat 2016/10/18 16:12:44 Realy -> Really
snake 2016/10/18 17:00:58 Done.
+ TestClient client;
+ client.SetCanUsePartialLoading();
+ 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 no requests, we should 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("{4980736,10485760}",
+ client.partial_loader_data()->open_byte_range.ToString());
+}
+
+TEST_F(DocumentLoaderTest, PartialLoadingBackOrder) {
+ TestClient client;
+ client.SetCanUsePartialLoading();
+
+ DocumentLoader loader(&client);
+ loader.Init(client.CreateFullPageLoader(), "http://url.com");
+
+ // While we have no requests, we should 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("{9830400,10485760}",
+ client.partial_loader_data()->open_byte_range.ToString());
+}
+
+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(10000ul, loader.GetDocumentSize());
+ 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(
+ static_cast<int>(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(0ul, loader.GetDocumentSize());
+ 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(DocumentLoader::kDefaultRequestSize + 1000 + 500,
+ static_cast<int>(loader.GetDocumentSize()));
+ 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(range_requested.start(),
+ client.partial_loader_data()->open_byte_range.start());
+ EXPECT_LE(range_requested.end(),
+ client.partial_loader_data()->open_byte_range.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.
spelchat 2016/10/18 16:12:44 because not other requests queued. -> because no o
snake 2016/10/18 17:00:57 Done.
+
+ loader.RequestData(18 * DocumentLoader::kDefaultRequestSize + 200, 20);
+ // Requests queue is processed only on data receving.
spelchat 2016/10/18 16:12:44 on receiving data. Same below.
snake 2016/10/18 17:00:57 Done.
+ client.partial_loader_data()->CallReadCallback(
+ DocumentLoader::kDefaultRequestSize);
+ // new requset with in close distance from current loading. Loading do not
spelchat 2016/10/18 16:12:44 "New request within close distance from the one cu
snake 2016/10/18 17:00:58 Done.
+ // 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(range_requested.start(),
+ client.partial_loader_data()->open_byte_range.start());
+ EXPECT_LE(range_requested.end(),
+ client.partial_loader_data()->open_byte_range.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(range_requested.start(),
+ client.partial_loader_data()->open_byte_range.start());
+ EXPECT_LE(range_requested.end(),
+ client.partial_loader_data()->open_byte_range.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(range_requested.start(),
+ client.partial_loader_data()->open_byte_range.start());
+ EXPECT_LE(range_requested.end(),
+ client.partial_loader_data()->open_byte_range.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(range_requested.start(),
+ client.partial_loader_data()->open_byte_range.start());
+ EXPECT_LE(range_requested.end(),
+ client.partial_loader_data()->open_byte_range.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(range_requested.start(),
+ client.partial_loader_data()->open_byte_range.start());
+ EXPECT_LE(range_requested.end(),
+ client.partial_loader_data()->open_byte_range.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.
spelchat 2016/10/18 16:12:44 should not have started
snake 2016/10/18 17:00:58 Done.
+ 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(range_requested.start(),
+ client.partial_loader_data()->open_byte_range.start());
+ EXPECT_LE(range_requested.end(),
+ client.partial_loader_data()->open_byte_range.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.
spelchat 2016/10/18 16:12:44 Partial loader is used to load the whole page...
snake 2016/10/18 17:00:58 Done.
+ 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(0., loader.GetProgress());
+
+ for (int i = 0; i < 20; ++i) {
+ EXPECT_EQ(i * 100 / 20, static_cast<int>(loader.GetProgress() * 100));
+ client.full_page_loader_data()->CallReadCallback(
+ DocumentLoader::kDefaultRequestSize);
+ }
+ EXPECT_EQ(1., loader.GetProgress());
+}
+
+TEST_F(DocumentLoaderTest, GetProgressNoContentLength) {
+ TestClient client;
+ DocumentLoader loader(&client);
+ loader.Init(client.CreateFullPageLoader(), "http://url.com");
+ EXPECT_EQ(-1., loader.GetProgress());
+
+ for (int i = 0; i < 20; ++i) {
+ EXPECT_EQ(-1., loader.GetProgress());
+ client.full_page_loader_data()->CallReadCallback(
+ DocumentLoader::kDefaultRequestSize);
+ }
+ client.full_page_loader_data()->CallReadCallback(0);
+ EXPECT_EQ(1., loader.GetProgress());
+}
+
+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
« no previous file with comments | « pdf/document_loader.cc ('k') | pdf/out_of_process_instance.h » ('j') | no next file with comments »

Powered by Google App Engine
This is Rietveld 408576698