pdf/document_loader_impl_unittest.cc

   1 // Copyright 2016 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "pdf/document_loader_impl.h"
   6
   7 #include <algorithm>
   8 #include <memory>
   9 #include <string>
  10 #include <vector>
  11
  12 #include "base/logging.h"
  13 #include "pdf/url_loader_wrapper.h"
  14 #include "testing/gmock/include/gmock/gmock.h"
  15 #include "testing/gtest/include/gtest/gtest.h"
  16 #include "ui/gfx/range/range.h"
  17
  18 using ::testing::_;
  19 using ::testing::Mock;
  20 using ::testing::Sequence;
  21 using ::testing::NiceMock;
  22 using ::testing::Return;
  23
  24 namespace chrome_pdf {
  25
  26 namespace {
  27
  28 constexpr uint32_t kDefaultRequestSize =
  29     DocumentLoaderImpl::kDefaultRequestSize;
  30
  31 class TestURLLoader : public URLLoaderWrapper {
  32  public:
  33   class LoaderData {
  34    public:
  35     LoaderData() = default;
  36     ~LoaderData() {
  37       // We should call callbacks to prevent memory leaks.
  38       // The callbacks don't do anything, because the objects that created the
  39       // callbacks have been destroyed.
  40       if (IsWaitRead())
  41         CallReadCallback(-1);
  42       if (IsWaitOpen())
  43         CallOpenCallback(-1);
  44     }
  45
  46     int content_length() const { return content_length_; }
  47     void set_content_length(int content_length) {
  48       content_length_ = content_length;
  49     }
  50     bool accept_ranges_bytes() const { return accept_ranges_bytes_; }
  51     void set_accept_ranges_bytes(bool accept_ranges_bytes) {
  52       accept_ranges_bytes_ = accept_ranges_bytes;
  53     }
  54     bool content_encoded() const { return content_encoded_; }
  55     void set_content_encoded(bool content_encoded) {
  56       content_encoded_ = content_encoded;
  57     }
  58     const std::string& content_type() const { return content_type_; }
  59     void set_content_type(const std::string& content_type) {
  60       content_type_ = content_type;
  61     }
  62     const std::string& content_disposition() const {
  63       return content_disposition_;
  64     }
  65     void set_content_disposition(const std::string& content_disposition) {
  66       content_disposition_ = content_disposition;
  67     }
  68     const std::string& multipart_boundary() const {
  69       return multipart_boundary_;
  70     }
  71     void set_multipart_boundary(const std::string& multipart_boundary) {
  72       multipart_boundary_ = multipart_boundary;
  73     }
  74     const gfx::Range& byte_range() const { return byte_range_; }
  75     void set_byte_range(const gfx::Range& byte_range) {
  76       byte_range_ = byte_range;
  77     }
  78     bool is_multipart() const { return is_multipart_; }
  79     void set_is_multipart(bool is_multipart) { is_multipart_ = is_multipart; }
  80     int status_code() const { return status_code_; }
  81     void set_status_code(int status_code) { status_code_ = status_code; }
  82     bool closed() const { return closed_; }
  83     void set_closed(bool closed) { closed_ = closed; }
  84     const gfx::Range& open_byte_range() const { return open_byte_range_; }
  85     void set_open_byte_range(const gfx::Range& open_byte_range) {
  86       open_byte_range_ = open_byte_range;
  87     }
  88
  89     bool IsWaitRead() const { return !did_read_callback_.IsOptional(); }
  90     bool IsWaitOpen() const { return !did_open_callback_.IsOptional(); }
  91     char* buffer() const { return buffer_; }
  92     int buffer_size() const { return buffer_size_; }
  93
  94     void SetReadCallback(const pp::CompletionCallback& read_callback,
  95                          char* buffer,
  96                          int buffer_size) {
  97       did_read_callback_ = read_callback;
  98       buffer_ = buffer;
  99       buffer_size_ = buffer_size;
 100     }
 101
 102     void SetOpenCallback(const pp::CompletionCallback& open_callback,
 103                          gfx::Range req_byte_range) {
 104       did_open_callback_ = open_callback;
 105       set_open_byte_range(req_byte_range);
 106     }
 107
 108     void CallOpenCallback(int result) {
 109       DCHECK(IsWaitOpen());
 110       did_open_callback_.RunAndClear(result);
 111     }
 112
 113     void CallReadCallback(int result) {
 114       DCHECK(IsWaitRead());
 115       did_read_callback_.RunAndClear(result);
 116     }
 117
 118    private:
 119     pp::CompletionCallback did_open_callback_;
 120     pp::CompletionCallback did_read_callback_;
 121     char* buffer_ = nullptr;
 122     int buffer_size_ = 0;
 123
 124     int content_length_ = -1;
 125     bool accept_ranges_bytes_ = false;
 126     bool content_encoded_ = false;
 127     std::string content_type_;
 128     std::string content_disposition_;
 129     std::string multipart_boundary_;
 130     gfx::Range byte_range_ = gfx::Range::InvalidRange();
 131     bool is_multipart_ = false;
 132     int status_code_ = 0;
 133     bool closed_ = true;
 134     gfx::Range open_byte_range_ = gfx::Range::InvalidRange();
 135
 136     DISALLOW_COPY_AND_ASSIGN(LoaderData);
 137   };
 138
 139   explicit TestURLLoader(LoaderData* data) : data_(data) {
 140     data_->set_closed(false);
 141   }
 142
 143   ~TestURLLoader() override { Close(); }
 144
 145   int GetContentLength() const override { return data_->content_length(); }
 146
 147   bool IsAcceptRangesBytes() const override {
 148     return data_->accept_ranges_bytes();
 149   }
 150
 151   bool IsContentEncoded() const override { return data_->content_encoded(); }
 152
 153   std::string GetContentType() const override { return data_->content_type(); }
 154
 155   std::string GetContentDisposition() const override {
 156     return data_->content_disposition();
 157   }
 158
 159   int GetStatusCode() const override { return data_->status_code(); }
 160
 161   bool IsMultipart() const override { return data_->is_multipart(); }
 162
 163   bool GetByteRangeStart(int* start) const override {
 164     *start = data_->byte_range().start();
 165     return data_->byte_range().IsValid();
 166   }
 167
 168   void Close() override { data_->set_closed(true); }
 169
 170   void OpenRange(const std::string& url,
 171                  const std::string& referrer_url,
 172                  uint32_t position,
 173                  uint32_t size,
 174                  const pp::CompletionCallback& cc) override {
 175     data_->SetOpenCallback(cc, gfx::Range(position, position + size));
 176   }
 177
 178   void ReadResponseBody(char* buffer,
 179                         int buffer_size,
 180                         const pp::CompletionCallback& cc) override {
 181     data_->SetReadCallback(cc, buffer, buffer_size);
 182   }
 183
 184   bool GetDownloadProgress(int64_t* bytes_received,
 185                            int64_t* total_bytes_to_be_received) const override {
 186     return false;
 187   }
 188
 189  private:
 190   LoaderData* data_;
 191
 192   DISALLOW_COPY_AND_ASSIGN(TestURLLoader);
 193 };
 194
 195 class TestClient : public DocumentLoader::Client {
 196  public:
 197   TestClient() { full_page_loader_data()->set_content_type("application/pdf"); }
 198   ~TestClient() override = default;
 199
 200   // DocumentLoader::Client overrides:
 201   pp::Instance* GetPluginInstance() override { return nullptr; }
 202   std::unique_ptr<URLLoaderWrapper> CreateURLLoader() override {
 203     return std::unique_ptr<URLLoaderWrapper>(
 204         new TestURLLoader(partial_loader_data()));
 205   }
 206   void OnPendingRequestComplete() override {}
 207   void OnNewDataReceived() override {}
 208   void OnDocumentComplete() override {}
 209   void OnDocumentCanceled() override {}
 210   void CancelBrowserDownload() override {}
 211
 212   std::unique_ptr<URLLoaderWrapper> CreateFullPageLoader() {
 213     return std::unique_ptr<URLLoaderWrapper>(
 214         new TestURLLoader(full_page_loader_data()));
 215   }
 216
 217   TestURLLoader::LoaderData* full_page_loader_data() {
 218     return &full_page_loader_data_;
 219   }
 220   TestURLLoader::LoaderData* partial_loader_data() {
 221     return &partial_loader_data_;
 222   }
 223
 224   void SetCanUsePartialLoading() {
 225     full_page_loader_data()->set_content_length(10 * 1024 * 1024);
 226     full_page_loader_data()->set_content_encoded(false);
 227     full_page_loader_data()->set_accept_ranges_bytes(true);
 228   }
 229
 230   void SendAllPartialData() {
 231     partial_loader_data_.set_byte_range(partial_loader_data_.open_byte_range());
 232     partial_loader_data_.CallOpenCallback(0);
 233     uint32_t length = partial_loader_data_.byte_range().length();
 234     while (length > 0) {
 235       constexpr uint32_t max_part_len = kDefaultRequestSize;
 236       const uint32_t part_len = std::min(length, max_part_len);
 237       partial_loader_data_.CallReadCallback(part_len);
 238       length -= part_len;
 239     }
 240     if (partial_loader_data_.IsWaitRead()) {
 241       partial_loader_data_.CallReadCallback(0);
 242     }
 243   }
 244
 245  private:
 246   TestURLLoader::LoaderData full_page_loader_data_;
 247   TestURLLoader::LoaderData partial_loader_data_;
 248
 249   DISALLOW_COPY_AND_ASSIGN(TestClient);
 250 };
 251
 252 class MockClient : public TestClient {
 253  public:
 254   MockClient() = default;
 255
 256   MOCK_METHOD0(OnPendingRequestComplete, void());
 257   MOCK_METHOD0(OnNewDataReceived, void());
 258   MOCK_METHOD0(OnDocumentComplete, void());
 259   MOCK_METHOD0(OnDocumentCanceled, void());
 260
 261  private:
 262   DISALLOW_COPY_AND_ASSIGN(MockClient);
 263 };
 264
 265 }  // namespace
 266
 267 using DocumentLoaderImplTest = ::testing::Test;
 268
 269 TEST_F(DocumentLoaderImplTest, PartialLoadingEnabled) {
 270   TestClient client;
 271   client.SetCanUsePartialLoading();
 272   DocumentLoaderImpl loader(&client);
 273   loader.Init(client.CreateFullPageLoader(), "http://url.com");
 274   loader.RequestData(1000000, 1);
 275   EXPECT_FALSE(loader.is_partial_loader_active());
 276   // Always send initial data from FullPageLoader.
 277   client.full_page_loader_data()->CallReadCallback(kDefaultRequestSize);
 278   EXPECT_TRUE(loader.is_partial_loader_active());
 279 }
 280
 281 TEST_F(DocumentLoaderImplTest, PartialLoadingDisabledOnSmallFiles) {
 282   TestClient client;
 283   client.SetCanUsePartialLoading();
 284   client.full_page_loader_data()->set_content_length(kDefaultRequestSize * 2);
 285   DocumentLoaderImpl loader(&client);
 286   loader.Init(client.CreateFullPageLoader(), "http://url.com");
 287   loader.RequestData(1000000, 1);
 288   EXPECT_FALSE(loader.is_partial_loader_active());
 289   // Always send initial data from FullPageLoader.
 290   client.full_page_loader_data()->CallReadCallback(kDefaultRequestSize);
 291   EXPECT_FALSE(loader.is_partial_loader_active());
 292 }
 293
 294 TEST_F(DocumentLoaderImplTest, PartialLoadingDisabledIfContentEncoded) {
 295   TestClient client;
 296   client.SetCanUsePartialLoading();
 297   client.full_page_loader_data()->set_content_encoded(true);
 298   DocumentLoaderImpl loader(&client);
 299   loader.Init(client.CreateFullPageLoader(), "http://url.com");
 300   loader.RequestData(1000000, 1);
 301   EXPECT_FALSE(loader.is_partial_loader_active());
 302   // Always send initial data from FullPageLoader.
 303   client.full_page_loader_data()->CallReadCallback(kDefaultRequestSize);
 304   EXPECT_FALSE(loader.is_partial_loader_active());
 305 }
 306
 307 TEST_F(DocumentLoaderImplTest, PartialLoadingDisabledNoAcceptRangeBytes) {
 308   TestClient client;
 309   client.SetCanUsePartialLoading();
 310   client.full_page_loader_data()->set_accept_ranges_bytes(false);
 311   DocumentLoaderImpl loader(&client);
 312   loader.Init(client.CreateFullPageLoader(), "http://url.com");
 313   loader.RequestData(1000000, 1);
 314   EXPECT_FALSE(loader.is_partial_loader_active());
 315   // Always send initial data from FullPageLoader.
 316   client.full_page_loader_data()->CallReadCallback(kDefaultRequestSize);
 317   EXPECT_FALSE(loader.is_partial_loader_active());
 318 }
 319
 320 TEST_F(DocumentLoaderImplTest, PartialLoadingReallyDisabledRequestFromBegin) {
 321   TestClient client;
 322   DocumentLoaderImpl loader(&client);
 323   client.SetCanUsePartialLoading();
 324   loader.SetPartialLoadingEnabled(false);
 325   loader.Init(client.CreateFullPageLoader(), "http://url.com");
 326   // We should not start partial loading if requested data is beside full page
 327   // loading position.
 328   loader.RequestData(kDefaultRequestSize, 1);
 329   EXPECT_FALSE(loader.is_partial_loader_active());
 330   // Always send initial data from FullPageLoader.
 331   client.full_page_loader_data()->CallReadCallback(kDefaultRequestSize);
 332   EXPECT_FALSE(loader.is_partial_loader_active());
 333 }
 334
 335 TEST_F(DocumentLoaderImplTest, PartialLoadingReallyDisabledRequestFromMiddle) {
 336   TestClient client;
 337   client.SetCanUsePartialLoading();
 338   DocumentLoaderImpl loader(&client);
 339   loader.SetPartialLoadingEnabled(false);
 340   loader.Init(client.CreateFullPageLoader(), "http://url.com");
 341   loader.RequestData(1000000, 1);
 342   EXPECT_FALSE(loader.is_partial_loader_active());
 343   // Always send initial data from FullPageLoader.
 344   client.full_page_loader_data()->CallReadCallback(kDefaultRequestSize);
 345   EXPECT_FALSE(loader.is_partial_loader_active());
 346 }
 347
 348 TEST_F(DocumentLoaderImplTest, PartialLoadingSimple) {
 349   TestClient client;
 350   client.SetCanUsePartialLoading();
 351
 352   DocumentLoaderImpl loader(&client);
 353   loader.Init(client.CreateFullPageLoader(), "http://url.com");
 354
 355   // While we have no requests, we should not start partial loading.
 356   EXPECT_FALSE(loader.is_partial_loader_active());
 357
 358   loader.RequestData(5000000, 1);
 359
 360   EXPECT_FALSE(client.partial_loader_data()->IsWaitOpen());
 361   EXPECT_FALSE(loader.is_partial_loader_active());
 362
 363   // Always send initial data from FullPageLoader.
 364   client.full_page_loader_data()->CallReadCallback(kDefaultRequestSize);
 365
 366   // Partial loader should request headers.
 367   EXPECT_TRUE(client.partial_loader_data()->IsWaitOpen());
 368   EXPECT_TRUE(loader.is_partial_loader_active());
 369   // Loader should be stopped.
 370   EXPECT_TRUE(client.full_page_loader_data()->closed());
 371
 372   EXPECT_EQ("{4980736,10485760}",
 373             client.partial_loader_data()->open_byte_range().ToString());
 374 }
 375
 376 TEST_F(DocumentLoaderImplTest, PartialLoadingBackOrder) {
 377   TestClient client;
 378   client.SetCanUsePartialLoading();
 379
 380   DocumentLoaderImpl loader(&client);
 381   loader.Init(client.CreateFullPageLoader(), "http://url.com");
 382
 383   // While we have no requests, we should not start partial loading.
 384   EXPECT_FALSE(loader.is_partial_loader_active());
 385
 386   loader.RequestData(client.full_page_loader_data()->content_length() - 1, 1);
 387
 388   EXPECT_FALSE(client.partial_loader_data()->IsWaitOpen());
 389   EXPECT_FALSE(loader.is_partial_loader_active());
 390
 391   // Always send initial data from FullPageLoader.
 392   client.full_page_loader_data()->CallReadCallback(kDefaultRequestSize);
 393
 394   // Partial loader should request headers.
 395   EXPECT_TRUE(client.partial_loader_data()->IsWaitOpen());
 396   EXPECT_TRUE(loader.is_partial_loader_active());
 397   // Loader should be stopped.
 398   EXPECT_TRUE(client.full_page_loader_data()->closed());
 399
 400   // Requested range should be enlarged.
 401   EXPECT_GT(client.partial_loader_data()->open_byte_range().length(), 1u);
 402   EXPECT_EQ("{9830400,10485760}",
 403             client.partial_loader_data()->open_byte_range().ToString());
 404 }
 405
 406 TEST_F(DocumentLoaderImplTest, CompleteWithoutPartial) {
 407   TestClient client;
 408   client.SetCanUsePartialLoading();
 409   DocumentLoaderImpl loader(&client);
 410   loader.Init(client.CreateFullPageLoader(), "http://url.com");
 411   EXPECT_FALSE(client.full_page_loader_data()->closed());
 412   while (client.full_page_loader_data()->IsWaitRead()) {
 413     client.full_page_loader_data()->CallReadCallback(1000);
 414   }
 415   EXPECT_TRUE(loader.IsDocumentComplete());
 416   EXPECT_TRUE(client.full_page_loader_data()->closed());
 417 }
 418
 419 TEST_F(DocumentLoaderImplTest, ErrorDownloadFullDocument) {
 420   TestClient client;
 421   client.SetCanUsePartialLoading();
 422   DocumentLoaderImpl loader(&client);
 423   loader.Init(client.CreateFullPageLoader(), "http://url.com");
 424   EXPECT_TRUE(client.full_page_loader_data()->IsWaitRead());
 425   EXPECT_FALSE(client.full_page_loader_data()->closed());
 426   client.full_page_loader_data()->CallReadCallback(-3);
 427   EXPECT_TRUE(client.full_page_loader_data()->closed());
 428   EXPECT_FALSE(loader.IsDocumentComplete());
 429 }
 430
 431 TEST_F(DocumentLoaderImplTest, CompleteNoContentLength) {
 432   TestClient client;
 433   DocumentLoaderImpl loader(&client);
 434   loader.Init(client.CreateFullPageLoader(), "http://url.com");
 435   EXPECT_FALSE(client.full_page_loader_data()->closed());
 436   for (int i = 0; i < 10; ++i) {
 437     EXPECT_TRUE(client.full_page_loader_data()->IsWaitRead());
 438     client.full_page_loader_data()->CallReadCallback(1000);
 439   }
 440   EXPECT_TRUE(client.full_page_loader_data()->IsWaitRead());
 441   client.full_page_loader_data()->CallReadCallback(0);
 442   EXPECT_EQ(10000ul, loader.GetDocumentSize());
 443   EXPECT_TRUE(loader.IsDocumentComplete());
 444   EXPECT_TRUE(client.full_page_loader_data()->closed());
 445 }
 446
 447 TEST_F(DocumentLoaderImplTest, CompleteWithPartial) {
 448   TestClient client;
 449   client.SetCanUsePartialLoading();
 450   client.full_page_loader_data()->set_content_length(kDefaultRequestSize * 20);
 451   DocumentLoaderImpl loader(&client);
 452   loader.Init(client.CreateFullPageLoader(), "http://url.com");
 453   loader.RequestData(19 * kDefaultRequestSize, kDefaultRequestSize);
 454   EXPECT_FALSE(client.full_page_loader_data()->closed());
 455   EXPECT_FALSE(client.partial_loader_data()->IsWaitRead());
 456   EXPECT_FALSE(client.partial_loader_data()->IsWaitOpen());
 457
 458   // Always send initial data from FullPageLoader.
 459   client.full_page_loader_data()->CallReadCallback(kDefaultRequestSize);
 460   EXPECT_TRUE(client.full_page_loader_data()->closed());
 461   EXPECT_FALSE(client.partial_loader_data()->closed());
 462
 463   client.SendAllPartialData();
 464   // Now we should send other document data.
 465   client.SendAllPartialData();
 466   EXPECT_TRUE(client.full_page_loader_data()->closed());
 467   EXPECT_TRUE(client.partial_loader_data()->closed());
 468 }
 469
 470 TEST_F(DocumentLoaderImplTest, PartialRequestLastChunk) {
 471   constexpr uint32_t kLastChunkSize = 300;
 472   TestClient client;
 473   client.SetCanUsePartialLoading();
 474   client.full_page_loader_data()->set_content_length(kDefaultRequestSize * 20 +
 475                                                      kLastChunkSize);
 476   DocumentLoaderImpl loader(&client);
 477   loader.Init(client.CreateFullPageLoader(), "http://url.com");
 478   loader.RequestData(20 * kDefaultRequestSize, 1);
 479
 480   // Always send initial data from FullPageLoader.
 481   client.full_page_loader_data()->CallReadCallback(kDefaultRequestSize);
 482
 483   EXPECT_TRUE(client.partial_loader_data()->IsWaitOpen());
 484   EXPECT_EQ(
 485       static_cast<int>(client.partial_loader_data()->open_byte_range().end()),
 486       client.full_page_loader_data()->content_length());
 487   client.partial_loader_data()->set_byte_range(
 488       client.partial_loader_data()->open_byte_range());
 489   client.partial_loader_data()->CallOpenCallback(0);
 490   uint32_t data_length = client.partial_loader_data()->byte_range().length();
 491   while (data_length > kDefaultRequestSize) {
 492     client.partial_loader_data()->CallReadCallback(kDefaultRequestSize);
 493     data_length -= kDefaultRequestSize;
 494   }
 495   EXPECT_EQ(kLastChunkSize, data_length);
 496   client.partial_loader_data()->CallReadCallback(kLastChunkSize);
 497   EXPECT_TRUE(loader.IsDataAvailable(kDefaultRequestSize * 20, kLastChunkSize));
 498 }
 499
 500 TEST_F(DocumentLoaderImplTest, DocumentSize) {
 501   TestClient client;
 502   client.SetCanUsePartialLoading();
 503   client.full_page_loader_data()->set_content_length(123456789);
 504   DocumentLoaderImpl loader(&client);
 505   loader.Init(client.CreateFullPageLoader(), "http://url.com");
 506   EXPECT_EQ(static_cast<int>(loader.GetDocumentSize()),
 507             client.full_page_loader_data()->content_length());
 508 }
 509
 510 TEST_F(DocumentLoaderImplTest, DocumentSizeNoContentLength) {
 511   TestClient client;
 512   DocumentLoaderImpl loader(&client);
 513   loader.Init(client.CreateFullPageLoader(), "http://url.com");
 514   EXPECT_EQ(0ul, loader.GetDocumentSize());
 515   client.full_page_loader_data()->CallReadCallback(kDefaultRequestSize);
 516   client.full_page_loader_data()->CallReadCallback(1000);
 517   client.full_page_loader_data()->CallReadCallback(500);
 518   client.full_page_loader_data()->CallReadCallback(0);
 519   EXPECT_EQ(kDefaultRequestSize + 1000ul + 500ul, loader.GetDocumentSize());
 520   EXPECT_TRUE(loader.IsDocumentComplete());
 521 }
 522
 523 TEST_F(DocumentLoaderImplTest, ClearPendingRequests) {
 524   TestClient client;
 525   client.SetCanUsePartialLoading();
 526   client.full_page_loader_data()->set_content_length(kDefaultRequestSize * 100 +
 527                                                      58383);
 528   DocumentLoaderImpl loader(&client);
 529   loader.Init(client.CreateFullPageLoader(), "http://url.com");
 530   loader.RequestData(17 * kDefaultRequestSize + 100, 10);
 531   loader.ClearPendingRequests();
 532   loader.RequestData(15 * kDefaultRequestSize + 200, 20);
 533   // pending requests are accumulating, and will be processed after initial data
 534   // load.
 535   EXPECT_FALSE(client.partial_loader_data()->IsWaitOpen());
 536
 537   // Send initial data from FullPageLoader.
 538   client.full_page_loader_data()->CallReadCallback(kDefaultRequestSize);
 539
 540   {
 541     EXPECT_TRUE(client.partial_loader_data()->IsWaitOpen());
 542     constexpr gfx::Range range_requested(15 * kDefaultRequestSize,
 543                                          16 * kDefaultRequestSize);
 544     EXPECT_EQ(range_requested.start(),
 545               client.partial_loader_data()->open_byte_range().start());
 546     EXPECT_LE(range_requested.end(),
 547               client.partial_loader_data()->open_byte_range().end());
 548     client.partial_loader_data()->set_byte_range(
 549         client.partial_loader_data()->open_byte_range());
 550   }
 551   // clear requests before Open callback.
 552   loader.ClearPendingRequests();
 553   // Current request should continue loading.
 554   EXPECT_TRUE(client.partial_loader_data()->IsWaitOpen());
 555   client.partial_loader_data()->CallOpenCallback(0);
 556   client.partial_loader_data()->CallReadCallback(kDefaultRequestSize);
 557   EXPECT_FALSE(client.partial_loader_data()->closed());
 558   // Current request should continue loading, because no other request queued.
 559
 560   loader.RequestData(18 * kDefaultRequestSize + 200, 20);
 561   // Requests queue is processed only on receiving data.
 562   client.partial_loader_data()->CallReadCallback(kDefaultRequestSize);
 563   // New request within close distance from the one currently loading. Loading
 564   // isn't restarted.
 565   EXPECT_FALSE(client.partial_loader_data()->IsWaitOpen());
 566
 567   loader.ClearPendingRequests();
 568   // request again two.
 569   loader.RequestData(60 * kDefaultRequestSize + 100, 10);
 570   loader.RequestData(35 * kDefaultRequestSize + 200, 20);
 571   // Requests queue is processed only on receiving data.
 572   client.partial_loader_data()->CallReadCallback(kDefaultRequestSize);
 573   {
 574     // new requset not with in close distance from current loading.
 575     // Loading should be restarted.
 576     EXPECT_TRUE(client.partial_loader_data()->IsWaitOpen());
 577     // The first requested chunk should be processed.
 578     constexpr gfx::Range range_requested(35 * kDefaultRequestSize,
 579                                          36 * kDefaultRequestSize);
 580     EXPECT_EQ(range_requested.start(),
 581               client.partial_loader_data()->open_byte_range().start());
 582     EXPECT_LE(range_requested.end(),
 583               client.partial_loader_data()->open_byte_range().end());
 584     client.partial_loader_data()->set_byte_range(
 585         client.partial_loader_data()->open_byte_range());
 586   }
 587   EXPECT_TRUE(client.partial_loader_data()->IsWaitOpen());
 588   client.partial_loader_data()->CallOpenCallback(0);
 589   // Override pending requests.
 590   loader.ClearPendingRequests();
 591   loader.RequestData(70 * kDefaultRequestSize + 100, 10);
 592
 593   // Requests queue is processed only on receiving data.
 594   client.partial_loader_data()->CallReadCallback(kDefaultRequestSize);
 595   {
 596     // New requset not with in close distance from current loading.
 597     // Loading should be restarted .
 598     EXPECT_TRUE(client.partial_loader_data()->IsWaitOpen());
 599     // The first requested chunk should be processed.
 600     constexpr gfx::Range range_requested(70 * kDefaultRequestSize,
 601                                          71 * kDefaultRequestSize);
 602     EXPECT_EQ(range_requested.start(),
 603               client.partial_loader_data()->open_byte_range().start());
 604     EXPECT_LE(range_requested.end(),
 605               client.partial_loader_data()->open_byte_range().end());
 606     client.partial_loader_data()->set_byte_range(
 607         client.partial_loader_data()->open_byte_range());
 608   }
 609   EXPECT_TRUE(client.partial_loader_data()->IsWaitOpen());
 610 }
 611
 612 TEST_F(DocumentLoaderImplTest, GetBlock) {
 613   std::vector<char> buffer(kDefaultRequestSize);
 614   TestClient client;
 615   client.SetCanUsePartialLoading();
 616   client.full_page_loader_data()->set_content_length(kDefaultRequestSize * 20 +
 617                                                      58383);
 618   DocumentLoaderImpl loader(&client);
 619   loader.Init(client.CreateFullPageLoader(), "http://url.com");
 620   EXPECT_FALSE(loader.GetBlock(0, 1000, buffer.data()));
 621   client.full_page_loader_data()->CallReadCallback(kDefaultRequestSize);
 622   EXPECT_TRUE(loader.GetBlock(0, 1000, buffer.data()));
 623   EXPECT_FALSE(loader.GetBlock(kDefaultRequestSize, 1500, buffer.data()));
 624   client.full_page_loader_data()->CallReadCallback(kDefaultRequestSize);
 625   EXPECT_TRUE(loader.GetBlock(kDefaultRequestSize, 1500, buffer.data()));
 626
 627   EXPECT_FALSE(loader.GetBlock(17 * kDefaultRequestSize, 3000, buffer.data()));
 628   loader.RequestData(17 * kDefaultRequestSize + 100, 10);
 629   EXPECT_FALSE(loader.GetBlock(17 * kDefaultRequestSize, 3000, buffer.data()));
 630
 631   // Requests queue is processed only on receiving data.
 632   client.full_page_loader_data()->CallReadCallback(kDefaultRequestSize);
 633
 634   client.SendAllPartialData();
 635   EXPECT_TRUE(loader.GetBlock(17 * kDefaultRequestSize, 3000, buffer.data()));
 636 }
 637
 638 TEST_F(DocumentLoaderImplTest, IsDataAvailable) {
 639   TestClient client;
 640   client.SetCanUsePartialLoading();
 641   client.full_page_loader_data()->set_content_length(kDefaultRequestSize * 20 +
 642                                                      58383);
 643   DocumentLoaderImpl loader(&client);
 644   loader.Init(client.CreateFullPageLoader(), "http://url.com");
 645   EXPECT_FALSE(loader.IsDataAvailable(0, 1000));
 646   client.full_page_loader_data()->CallReadCallback(kDefaultRequestSize);
 647   EXPECT_TRUE(loader.IsDataAvailable(0, 1000));
 648   EXPECT_FALSE(loader.IsDataAvailable(kDefaultRequestSize, 1500));
 649   client.full_page_loader_data()->CallReadCallback(kDefaultRequestSize);
 650   EXPECT_TRUE(loader.IsDataAvailable(kDefaultRequestSize, 1500));
 651
 652   EXPECT_FALSE(loader.IsDataAvailable(17 * kDefaultRequestSize, 3000));
 653   loader.RequestData(17 * kDefaultRequestSize + 100, 10);
 654   EXPECT_FALSE(loader.IsDataAvailable(17 * kDefaultRequestSize, 3000));
 655
 656   // Requests queue is processed only on receiving data.
 657   client.full_page_loader_data()->CallReadCallback(kDefaultRequestSize);
 658
 659   client.SendAllPartialData();
 660   EXPECT_TRUE(loader.IsDataAvailable(17 * kDefaultRequestSize, 3000));
 661 }
 662
 663 TEST_F(DocumentLoaderImplTest, RequestData) {
 664   TestClient client;
 665   client.SetCanUsePartialLoading();
 666   client.full_page_loader_data()->set_content_length(kDefaultRequestSize * 100 +
 667                                                      58383);
 668   DocumentLoaderImpl loader(&client);
 669   loader.Init(client.CreateFullPageLoader(), "http://url.com");
 670   loader.RequestData(37 * kDefaultRequestSize + 200, 10);
 671   loader.RequestData(25 * kDefaultRequestSize + 600, 100);
 672   loader.RequestData(13 * kDefaultRequestSize + 900, 500);
 673
 674   // Send initial data from FullPageLoader.
 675   client.full_page_loader_data()->CallReadCallback(kDefaultRequestSize);
 676
 677   {
 678     EXPECT_TRUE(client.partial_loader_data()->IsWaitOpen());
 679     constexpr gfx::Range range_requested(13 * kDefaultRequestSize,
 680                                          14 * kDefaultRequestSize);
 681     EXPECT_EQ(range_requested.start(),
 682               client.partial_loader_data()->open_byte_range().start());
 683     EXPECT_LE(range_requested.end(),
 684               client.partial_loader_data()->open_byte_range().end());
 685     client.partial_loader_data()->set_byte_range(
 686         client.partial_loader_data()->open_byte_range());
 687   }
 688   client.partial_loader_data()->CallOpenCallback(0);
 689   // Override pending requests.
 690   loader.ClearPendingRequests();
 691   loader.RequestData(38 * kDefaultRequestSize + 200, 10);
 692   loader.RequestData(26 * kDefaultRequestSize + 600, 100);
 693   // Requests queue is processed only on receiving data.
 694   client.partial_loader_data()->CallReadCallback(kDefaultRequestSize);
 695   {
 696     EXPECT_TRUE(client.partial_loader_data()->IsWaitOpen());
 697     constexpr gfx::Range range_requested(26 * kDefaultRequestSize,
 698                                          27 * kDefaultRequestSize);
 699     EXPECT_EQ(range_requested.start(),
 700               client.partial_loader_data()->open_byte_range().start());
 701     EXPECT_LE(range_requested.end(),
 702               client.partial_loader_data()->open_byte_range().end());
 703     client.partial_loader_data()->set_byte_range(
 704         client.partial_loader_data()->open_byte_range());
 705   }
 706   client.partial_loader_data()->CallOpenCallback(0);
 707   // Override pending requests.
 708   loader.ClearPendingRequests();
 709   loader.RequestData(39 * kDefaultRequestSize + 200, 10);
 710   // Requests queue is processed only on receiving data.
 711   client.partial_loader_data()->CallReadCallback(kDefaultRequestSize);
 712   {
 713     EXPECT_TRUE(client.partial_loader_data()->IsWaitOpen());
 714     constexpr gfx::Range range_requested(39 * kDefaultRequestSize,
 715                                          40 * kDefaultRequestSize);
 716     EXPECT_EQ(range_requested.start(),
 717               client.partial_loader_data()->open_byte_range().start());
 718     EXPECT_LE(range_requested.end(),
 719               client.partial_loader_data()->open_byte_range().end());
 720     client.partial_loader_data()->set_byte_range(
 721         client.partial_loader_data()->open_byte_range());
 722   }
 723   // Fill all gaps.
 724   while (!loader.IsDocumentComplete()) {
 725     client.SendAllPartialData();
 726   }
 727   EXPECT_TRUE(client.partial_loader_data()->closed());
 728 }
 729
 730 TEST_F(DocumentLoaderImplTest, DoNotLoadAvailablePartialData) {
 731   TestClient client;
 732   client.SetCanUsePartialLoading();
 733   client.full_page_loader_data()->set_content_length(kDefaultRequestSize * 20 +
 734                                                      58383);
 735   DocumentLoaderImpl loader(&client);
 736   loader.Init(client.CreateFullPageLoader(), "http://url.com");
 737   // Send initial data from FullPageLoader.
 738   client.full_page_loader_data()->CallReadCallback(kDefaultRequestSize);
 739
 740   // Send more data from FullPageLoader.
 741   client.full_page_loader_data()->CallReadCallback(kDefaultRequestSize);
 742
 743   loader.RequestData(2 * kDefaultRequestSize + 200, 10);
 744
 745   // Send more data from FullPageLoader.
 746   client.full_page_loader_data()->CallReadCallback(kDefaultRequestSize);
 747
 748   // Partial loading should not have started for already available data.
 749   EXPECT_TRUE(client.partial_loader_data()->closed());
 750 }
 751
 752 TEST_F(DocumentLoaderImplTest, DoNotLoadDataAfterComplete) {
 753   TestClient client;
 754   client.SetCanUsePartialLoading();
 755   client.full_page_loader_data()->set_content_length(kDefaultRequestSize * 20);
 756   DocumentLoaderImpl loader(&client);
 757   loader.Init(client.CreateFullPageLoader(), "http://url.com");
 758
 759   for (int i = 0; i < 20; ++i) {
 760     client.full_page_loader_data()->CallReadCallback(kDefaultRequestSize);
 761   }
 762
 763   EXPECT_TRUE(loader.IsDocumentComplete());
 764
 765   loader.RequestData(17 * kDefaultRequestSize + 200, 10);
 766
 767   EXPECT_TRUE(client.partial_loader_data()->closed());
 768   EXPECT_TRUE(client.full_page_loader_data()->closed());
 769 }
 770
 771 TEST_F(DocumentLoaderImplTest, DoNotLoadPartialDataAboveDocumentSize) {
 772   TestClient client;
 773   client.SetCanUsePartialLoading();
 774   client.full_page_loader_data()->set_content_length(kDefaultRequestSize * 20);
 775   DocumentLoaderImpl loader(&client);
 776   loader.Init(client.CreateFullPageLoader(), "http://url.com");
 777
 778   loader.RequestData(20 * kDefaultRequestSize + 200, 10);
 779
 780   // Send initial data from FullPageLoader.
 781   client.full_page_loader_data()->CallReadCallback(kDefaultRequestSize);
 782
 783   EXPECT_TRUE(client.partial_loader_data()->closed());
 784 }
 785
 786 TEST_F(DocumentLoaderImplTest, MergePendingRequests) {
 787   TestClient client;
 788   client.SetCanUsePartialLoading();
 789   client.full_page_loader_data()->set_content_length(kDefaultRequestSize * 50 +
 790                                                      58383);
 791   DocumentLoaderImpl loader(&client);
 792   loader.Init(client.CreateFullPageLoader(), "http://url.com");
 793   loader.RequestData(17 * kDefaultRequestSize + 200, 10);
 794   loader.RequestData(16 * kDefaultRequestSize + 600, 100);
 795
 796   // Send initial data from FullPageLoader.
 797   client.full_page_loader_data()->CallReadCallback(kDefaultRequestSize);
 798
 799   constexpr gfx::Range range_requested(16 * kDefaultRequestSize,
 800                                        18 * kDefaultRequestSize);
 801   EXPECT_EQ(range_requested.start(),
 802             client.partial_loader_data()->open_byte_range().start());
 803   EXPECT_LE(range_requested.end(),
 804             client.partial_loader_data()->open_byte_range().end());
 805
 806   EXPECT_TRUE(client.partial_loader_data()->IsWaitOpen());
 807
 808   // Fill all gaps.
 809   while (!loader.IsDocumentComplete()) {
 810     client.SendAllPartialData();
 811   }
 812   EXPECT_TRUE(client.partial_loader_data()->closed());
 813 }
 814
 815 TEST_F(DocumentLoaderImplTest, PartialStopOnStatusCodeError) {
 816   TestClient client;
 817   client.SetCanUsePartialLoading();
 818   client.full_page_loader_data()->set_content_length(kDefaultRequestSize * 20);
 819   DocumentLoaderImpl loader(&client);
 820   loader.Init(client.CreateFullPageLoader(), "http://url.com");
 821
 822   loader.RequestData(17 * kDefaultRequestSize + 200, 10);
 823
 824   // Send initial data from FullPageLoader.
 825   client.full_page_loader_data()->CallReadCallback(kDefaultRequestSize);
 826
 827   EXPECT_TRUE(client.partial_loader_data()->IsWaitOpen());
 828   client.partial_loader_data()->set_status_code(404);
 829   client.partial_loader_data()->CallOpenCallback(0);
 830   EXPECT_TRUE(client.partial_loader_data()->closed());
 831 }
 832
 833 TEST_F(DocumentLoaderImplTest,
 834        PartialAsFullDocumentLoadingRangeRequestNoRangeField) {
 835   TestClient client;
 836   client.SetCanUsePartialLoading();
 837   client.full_page_loader_data()->set_content_length(kDefaultRequestSize * 20);
 838   DocumentLoaderImpl loader(&client);
 839   loader.Init(client.CreateFullPageLoader(), "http://url.com");
 840
 841   loader.RequestData(17 * kDefaultRequestSize + 200, 10);
 842
 843   // Send initial data from FullPageLoader.
 844   client.full_page_loader_data()->CallReadCallback(kDefaultRequestSize);
 845
 846   EXPECT_TRUE(client.partial_loader_data()->IsWaitOpen());
 847   client.partial_loader_data()->set_byte_range(gfx::Range::InvalidRange());
 848   client.partial_loader_data()->CallOpenCallback(0);
 849   EXPECT_FALSE(client.partial_loader_data()->closed());
 850   // Partial loader is used to load the whole page, like full page loader.
 851   EXPECT_FALSE(loader.is_partial_loader_active());
 852 }
 853
 854 TEST_F(DocumentLoaderImplTest, PartialMultiPart) {
 855   TestClient client;
 856   client.SetCanUsePartialLoading();
 857   client.full_page_loader_data()->set_content_length(kDefaultRequestSize * 20);
 858   DocumentLoaderImpl loader(&client);
 859   loader.Init(client.CreateFullPageLoader(), "http://url.com");
 860
 861   loader.RequestData(17 * kDefaultRequestSize + 200, 10);
 862
 863   // Send initial data from FullPageLoader.
 864   client.full_page_loader_data()->CallReadCallback(kDefaultRequestSize);
 865
 866   EXPECT_TRUE(client.partial_loader_data()->IsWaitOpen());
 867   client.partial_loader_data()->set_is_multipart(true);
 868   client.partial_loader_data()->CallOpenCallback(0);
 869   client.partial_loader_data()->set_byte_range(
 870       gfx::Range(17 * kDefaultRequestSize, 18 * kDefaultRequestSize));
 871   client.partial_loader_data()->CallReadCallback(kDefaultRequestSize);
 872   EXPECT_TRUE(
 873       loader.IsDataAvailable(17 * kDefaultRequestSize, kDefaultRequestSize));
 874 }
 875
 876 TEST_F(DocumentLoaderImplTest, PartialMultiPartRangeError) {
 877   TestClient client;
 878   client.SetCanUsePartialLoading();
 879   client.full_page_loader_data()->set_content_length(kDefaultRequestSize * 20);
 880   DocumentLoaderImpl loader(&client);
 881   loader.Init(client.CreateFullPageLoader(), "http://url.com");
 882
 883   loader.RequestData(17 * kDefaultRequestSize + 200, 10);
 884
 885   // Send initial data from FullPageLoader.
 886   client.full_page_loader_data()->CallReadCallback(kDefaultRequestSize);
 887
 888   EXPECT_TRUE(client.partial_loader_data()->IsWaitOpen());
 889   client.partial_loader_data()->set_is_multipart(true);
 890   client.partial_loader_data()->CallOpenCallback(0);
 891   client.partial_loader_data()->set_byte_range(gfx::Range::InvalidRange());
 892   client.partial_loader_data()->CallReadCallback(kDefaultRequestSize);
 893   EXPECT_FALSE(
 894       loader.IsDataAvailable(17 * kDefaultRequestSize, kDefaultRequestSize));
 895   EXPECT_TRUE(client.partial_loader_data()->closed());
 896 }
 897
 898 TEST_F(DocumentLoaderImplTest, PartialConnectionErrorOnOpen) {
 899   TestClient client;
 900   client.SetCanUsePartialLoading();
 901   client.full_page_loader_data()->set_content_length(kDefaultRequestSize * 20);
 902   DocumentLoaderImpl loader(&client);
 903   loader.Init(client.CreateFullPageLoader(), "http://url.com");
 904
 905   loader.RequestData(17 * kDefaultRequestSize + 200, 10);
 906
 907   // Send initial data from FullPageLoader.
 908   client.full_page_loader_data()->CallReadCallback(kDefaultRequestSize);
 909
 910   EXPECT_TRUE(client.partial_loader_data()->IsWaitOpen());
 911   client.partial_loader_data()->CallOpenCallback(-3);
 912   EXPECT_TRUE(client.partial_loader_data()->closed());
 913
 914   // Partial loading should not restart after any error.
 915   loader.RequestData(18 * kDefaultRequestSize + 200, 10);
 916
 917   EXPECT_FALSE(client.partial_loader_data()->IsWaitOpen());
 918   EXPECT_TRUE(client.partial_loader_data()->closed());
 919 }
 920
 921 TEST_F(DocumentLoaderImplTest, PartialConnectionErrorOnRead) {
 922   TestClient client;
 923   client.SetCanUsePartialLoading();
 924   client.full_page_loader_data()->set_content_length(kDefaultRequestSize * 20);
 925   DocumentLoaderImpl loader(&client);
 926   loader.Init(client.CreateFullPageLoader(), "http://url.com");
 927
 928   loader.RequestData(17 * kDefaultRequestSize + 200, 10);
 929
 930   // Send initial data from FullPageLoader.
 931   client.full_page_loader_data()->CallReadCallback(kDefaultRequestSize);
 932
 933   EXPECT_TRUE(client.partial_loader_data()->IsWaitOpen());
 934   client.partial_loader_data()->set_byte_range(
 935       gfx::Range(17 * kDefaultRequestSize, 18 * kDefaultRequestSize));
 936   client.partial_loader_data()->CallOpenCallback(0);
 937   EXPECT_TRUE(client.partial_loader_data()->IsWaitRead());
 938   client.partial_loader_data()->CallReadCallback(-3);
 939   EXPECT_TRUE(client.partial_loader_data()->closed());
 940
 941   // Partial loading should not restart after any error.
 942   loader.RequestData(18 * kDefaultRequestSize + 200, 10);
 943
 944   EXPECT_FALSE(client.partial_loader_data()->IsWaitOpen());
 945   EXPECT_TRUE(client.partial_loader_data()->closed());
 946 }
 947
 948 TEST_F(DocumentLoaderImplTest, ClientCompleteCallbacks) {
 949   MockClient client;
 950   client.SetCanUsePartialLoading();
 951   client.full_page_loader_data()->set_content_length(kDefaultRequestSize * 20);
 952   DocumentLoaderImpl loader(&client);
 953   loader.Init(client.CreateFullPageLoader(), "http://url.com");
 954
 955   EXPECT_CALL(client, OnDocumentComplete()).Times(0);
 956   for (int i = 0; i < 19; ++i)
 957     client.full_page_loader_data()->CallReadCallback(kDefaultRequestSize);
 958   Mock::VerifyAndClear(&client);
 959
 960   EXPECT_CALL(client, OnDocumentComplete()).Times(1);
 961   client.full_page_loader_data()->CallReadCallback(kDefaultRequestSize);
 962   Mock::VerifyAndClear(&client);
 963 }
 964
 965 TEST_F(DocumentLoaderImplTest, ClientCompleteCallbacksNoContentLength) {
 966   MockClient client;
 967   DocumentLoaderImpl loader(&client);
 968   loader.Init(client.CreateFullPageLoader(), "http://url.com");
 969
 970   EXPECT_CALL(client, OnDocumentCanceled()).Times(0);
 971   EXPECT_CALL(client, OnDocumentComplete()).Times(0);
 972   for (int i = 0; i < 20; ++i)
 973     client.full_page_loader_data()->CallReadCallback(kDefaultRequestSize);
 974   Mock::VerifyAndClear(&client);
 975
 976   EXPECT_CALL(client, OnDocumentCanceled()).Times(0);
 977   EXPECT_CALL(client, OnDocumentComplete()).Times(1);
 978   client.full_page_loader_data()->CallReadCallback(0);
 979   Mock::VerifyAndClear(&client);
 980 }
 981
 982 TEST_F(DocumentLoaderImplTest, ClientCancelCallback) {
 983   MockClient client;
 984   client.SetCanUsePartialLoading();
 985   client.full_page_loader_data()->set_content_length(kDefaultRequestSize * 20);
 986   DocumentLoaderImpl loader(&client);
 987   loader.Init(client.CreateFullPageLoader(), "http://url.com");
 988
 989   EXPECT_CALL(client, OnDocumentCanceled()).Times(0);
 990   EXPECT_CALL(client, OnDocumentComplete()).Times(0);
 991   for (int i = 0; i < 10; ++i)
 992     client.full_page_loader_data()->CallReadCallback(kDefaultRequestSize);
 993   Mock::VerifyAndClear(&client);
 994
 995   EXPECT_CALL(client, OnDocumentComplete()).Times(0);
 996   EXPECT_CALL(client, OnDocumentCanceled()).Times(1);
 997   client.full_page_loader_data()->CallReadCallback(-3);
 998   Mock::VerifyAndClear(&client);
 999 }
1000
1001 TEST_F(DocumentLoaderImplTest, NewDataAvailable) {
1002   MockClient client;
1003   client.SetCanUsePartialLoading();
1004   client.full_page_loader_data()->set_content_length(kDefaultRequestSize * 20);
1005   DocumentLoaderImpl loader(&client);
1006   loader.Init(client.CreateFullPageLoader(), "http://url.com");
1007
1008   EXPECT_CALL(client, OnNewDataReceived()).Times(1);
1009   client.full_page_loader_data()->CallReadCallback(kDefaultRequestSize);
1010   Mock::VerifyAndClear(&client);
1011
1012   EXPECT_CALL(client, OnNewDataReceived()).Times(1);
1013   client.full_page_loader_data()->CallReadCallback(kDefaultRequestSize - 100);
1014   Mock::VerifyAndClear(&client);
1015
1016   EXPECT_CALL(client, OnNewDataReceived()).Times(1);
1017   client.full_page_loader_data()->CallReadCallback(100);
1018   Mock::VerifyAndClear(&client);
1019 }
1020
1021 TEST_F(DocumentLoaderImplTest, ClientPendingRequestCompleteFullLoader) {
1022   MockClient client;
1023   client.SetCanUsePartialLoading();
1024   DocumentLoaderImpl loader(&client);
1025   loader.Init(client.CreateFullPageLoader(), "http://url.com");
1026
1027   loader.RequestData(1000, 4000);
1028
1029   EXPECT_CALL(client, OnPendingRequestComplete()).Times(1);
1030   client.full_page_loader_data()->CallReadCallback(kDefaultRequestSize);
1031   Mock::VerifyAndClear(&client);
1032 }
1033
1034 TEST_F(DocumentLoaderImplTest, ClientPendingRequestCompletePartialLoader) {
1035   MockClient client;
1036   client.SetCanUsePartialLoading();
1037   DocumentLoaderImpl loader(&client);
1038   loader.Init(client.CreateFullPageLoader(), "http://url.com");
1039
1040   EXPECT_CALL(client, OnPendingRequestComplete()).Times(1);
1041   loader.RequestData(15 * kDefaultRequestSize + 4000, 4000);
1042
1043   // Always send initial data from FullPageLoader.
1044   client.full_page_loader_data()->CallReadCallback(kDefaultRequestSize);
1045
1046   client.SendAllPartialData();
1047   Mock::VerifyAndClear(&client);
1048 }
1049
1050 TEST_F(DocumentLoaderImplTest,
1051        ClientPendingRequestCompletePartialAndFullLoader) {
1052   MockClient client;
1053   client.SetCanUsePartialLoading();
1054   DocumentLoaderImpl loader(&client);
1055   loader.Init(client.CreateFullPageLoader(), "http://url.com");
1056
1057   EXPECT_CALL(client, OnPendingRequestComplete()).Times(1);
1058   loader.RequestData(16 * kDefaultRequestSize + 4000, 4000);
1059   loader.RequestData(4 * kDefaultRequestSize + 4000, 4000);
1060
1061   for (int i = 0; i < 5; ++i)
1062     client.full_page_loader_data()->CallReadCallback(kDefaultRequestSize);
1063
1064   Mock::VerifyAndClear(&client);
1065
1066   EXPECT_CALL(client, OnPendingRequestComplete()).Times(1);
1067   client.SendAllPartialData();
1068   Mock::VerifyAndClear(&client);
1069 }
1070
1071 TEST_F(DocumentLoaderImplTest, IgnoreDataMoreThanExpectedWithPartial) {
1072   static constexpr uint32_t kDocSize = kDefaultRequestSize * 80 - 321;
1073   TestClient client;
1074   client.SetCanUsePartialLoading();
1075   client.full_page_loader_data()->set_content_length(kDocSize);
1076   DocumentLoaderImpl loader(&client);
1077   loader.Init(client.CreateFullPageLoader(), "http://url.com");
1078   // Request data at and.
1079   loader.RequestData(kDocSize - 100, 100);
1080
1081   // Always send initial data from FullPageLoader.
1082   client.full_page_loader_data()->CallReadCallback(kDefaultRequestSize);
1083   EXPECT_TRUE(client.full_page_loader_data()->closed());
1084   EXPECT_FALSE(client.partial_loader_data()->closed());
1085
1086   // Request data at middle to continue loading partial, but not all remaining
1087   // data.
1088   loader.RequestData(kDocSize / 2, 100);
1089
1090   // Fill data at the end, the partial loding should be started for second
1091   // requested data after receive data for first request.
1092   client.SendAllPartialData();
1093
1094   ASSERT_TRUE(client.partial_loader_data()->IsWaitOpen());
1095   // Process second request.
1096   const uint32_t expected_length =
1097       client.partial_loader_data()->open_byte_range().length();
1098
1099   // Send data.
1100   client.partial_loader_data()->set_byte_range(
1101       client.partial_loader_data()->open_byte_range());
1102   client.partial_loader_data()->CallOpenCallback(0);
1103   uint32_t length = expected_length;
1104   while (length > 0) {
1105     constexpr uint32_t max_part_len = kDefaultRequestSize;
1106     const uint32_t part_len = std::min(length, max_part_len);
1107     client.partial_loader_data()->CallReadCallback(part_len);
1108     length -= part_len;
1109   }
1110
1111   // The partial loading should be finished for current chunks sequence, if
1112   // expected range was received, and remaining sequence should start loading.
1113   EXPECT_FALSE(client.partial_loader_data()->IsWaitRead());
1114   ASSERT_TRUE(client.partial_loader_data()->IsWaitOpen());
1115
1116   // Send other document data.
1117   client.SendAllPartialData();
1118   // The downloads should be finished.
1119   EXPECT_TRUE(client.full_page_loader_data()->closed());
1120   EXPECT_TRUE(client.partial_loader_data()->closed());
1121 }
1122
1123 TEST_F(DocumentLoaderImplTest, IgnoreDataMoreThanExpectedWithPartialAtFileEnd) {
1124   static constexpr uint32_t kExtraSize = 100;
1125   static constexpr uint32_t kRealSize = kDefaultRequestSize * 20 - 300;
1126   static constexpr uint32_t kDocSize = kRealSize - kExtraSize;
1127   TestClient client;
1128   client.SetCanUsePartialLoading();
1129   client.full_page_loader_data()->set_content_length(kDocSize);
1130   DocumentLoaderImpl loader(&client);
1131   loader.Init(client.CreateFullPageLoader(), "http://url.com");
1132   // Request data at middle.
1133   static constexpr uint32_t kFirstPartial = kDefaultRequestSize * 11;
1134   loader.RequestData(kFirstPartial, kDefaultRequestSize);
1135
1136   // Always send initial data from FullPageLoader.
1137   client.full_page_loader_data()->CallReadCallback(kDefaultRequestSize);
1138   EXPECT_TRUE(client.full_page_loader_data()->closed());
1139   EXPECT_FALSE(client.partial_loader_data()->closed());
1140
1141   // Send data to file end and extra non expected data.
1142   client.partial_loader_data()->set_byte_range(
1143       gfx::Range(kFirstPartial, kRealSize));
1144   client.partial_loader_data()->CallOpenCallback(0);
1145   uint32_t length = client.partial_loader_data()->byte_range().length();
1146   while (length > 0) {
1147     constexpr uint32_t max_part_len = kDefaultRequestSize;
1148     const uint32_t part_len = std::min(length, max_part_len);
1149     client.partial_loader_data()->CallReadCallback(part_len);
1150     length -= part_len;
1151   }
1152
1153   // The partial loading should be finished for current chunks sequence, if
1154   // eof was reached, and remaining sequence should start loading.
1155   EXPECT_FALSE(client.partial_loader_data()->IsWaitRead());
1156   EXPECT_EQ(gfx::Range(kDefaultRequestSize, kFirstPartial),
1157             client.partial_loader_data()->open_byte_range());
1158
1159   // Send other document data.
1160   client.SendAllPartialData();
1161   // The downloads should be finished.
1162   EXPECT_TRUE(client.full_page_loader_data()->closed());
1163   EXPECT_TRUE(client.partial_loader_data()->closed());
1164 }
1165
1166 }  // namespace chrome_pdf