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..7f5dedaeac3a80e5d64ff260577df2d36bd1b0ec |
--- /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 { |
Lei Zhang
2016/10/21 09:33:09
nit: blank line after the beginning of the namespa
snake
2016/10/21 15:13:15
Done.
|
+class TestURLLoader : public URLLoaderWrapper { |
+ public: |
+ struct LoaderData { |
Lei Zhang
2016/10/21 09:33:09
This need to be a class. https://google.github.io/
snake
2016/10/21 15:13:15
Done.
|
+ 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_; |
Lei Zhang
2016/10/21 09:33:09
Does SetOpenCallback() always pass in a |open_call
snake
2016/10/21 15:13:15
Done.
|
+ bool wait_read_ = false; |
+ pp::CompletionCallback did_read_callback_; |
+ char* buffer_ = nullptr; |
Lei Zhang
2016/10/21 09:33:09
Can this be a std::vector<char> instead? And std::
snake
2016/10/21 15:13:15
No, this buffer passed into SetReadCallback
|
+ 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_; |
+}; |
Lei Zhang
2016/10/21 09:33:09
Please use DISALLOW_COPY_AND_ASSIGN(ClassName) lib
snake
2016/10/21 15:13:15
Done.
|
+ |
+class TestClient : public DocumentLoader::Client { |
+ public: |
+ TestClient() { full_page_loader_data()->content_type = "application/pdf"; } |
+ ~TestClient() override {} |
Lei Zhang
2016/10/21 09:33:09
nit: blank line after
snake
2016/10/21 15:13:15
Done.
|
+ // 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, PartialLoadingReallyDisabledRequestFromBegin) { |
+ 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, PartialLoadingReallyDisabledRequestFromMiddle) { |
+ 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 no other request queued. |
+ |
+ loader.RequestData(18 * DocumentLoader::kDefaultRequestSize + 200, 20); |
+ // Requests queue is processed only on receiving data. |
+ client.partial_loader_data()->CallReadCallback( |
+ DocumentLoader::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); |
+ // Requests queue is processed only on receiving data. |
+ 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 receiving data. |
+ 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 receiving data. |
+ 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 receiving data. |
+ 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 receiving data. |
+ 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 receiving data. |
+ 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 have 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(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 the 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(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 |