src/content/child/web_url_loader_impl_unittest.cc

   1 // Copyright 2014 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 "content/child/web_url_loader_impl.h"
   6
   7 #include <string.h>
   8
   9 #include "base/command_line.h"
  10 #include "base/macros.h"
  11 #include "base/memory/weak_ptr.h"
  12 #include "base/message_loop/message_loop.h"
  13 #include "base/time/time.h"
  14 #include "content/child/request_extra_data.h"
  15 #include "content/child/request_info.h"
  16 #include "content/child/resource_dispatcher.h"
  17 #include "content/child/resource_loader_bridge.h"
  18 #include "content/public/child/request_peer.h"
  19 #include "content/public/common/content_switches.h"
  20 #include "content/public/common/resource_response_info.h"
  21 #include "net/base/net_errors.h"
  22 #include "net/http/http_response_headers.h"
  23 #include "net/http/http_util.h"
  24 #include "net/url_request/redirect_info.h"
  25 #include "testing/gtest/include/gtest/gtest.h"
  26 #include "third_party/WebKit/public/platform/WebString.h"
  27 #include "third_party/WebKit/public/platform/WebURLError.h"
  28 #include "third_party/WebKit/public/platform/WebURLLoaderClient.h"
  29 #include "third_party/WebKit/public/platform/WebURLRequest.h"
  30 #include "third_party/WebKit/public/platform/WebURLResponse.h"
  31 #include "url/gurl.h"
  32
  33 namespace content {
  34 namespace {
  35
  36 const char kTestURL[] = "http://foo";
  37 const char kTestData[] = "blah!";
  38
  39 const char kFtpDirMimeType[] = "text/vnd.chromium.ftp-dir";
  40 // Simple FTP directory listing.  Tests are not concerned with correct parsing,
  41 // but rather correct cleanup when deleted while parsing.  Important details of
  42 // this list are that it contains more than one entry that are not "." or "..".
  43 const char kFtpDirListing[] =
  44     "drwxr-xr-x    3 ftp      ftp          4096 May 15 18:11 goat\n"
  45     "drwxr-xr-x    3 ftp      ftp          4096 May 15 18:11 hat";
  46
  47 const char kMultipartResponseMimeType[] = "multipart/x-mixed-replace";
  48 const char kMultipartResponseHeaders[] =
  49     "HTTP/1.0 200 Peachy\r\n"
  50     "Content-Type: multipart/x-mixed-replace; boundary=boundary\r\n\r\n";
  51 // Simple multipart response.  Imporant details for the tests are that it
  52 // contains multiple chunks, and that it doesn't end with a boundary, so will
  53 // send data in OnResponseComplete.  Also, it will resolve to kTestData.
  54 const char kMultipartResponse[] =
  55     "--boundary\n"
  56     "Content-type: text/html\n\n"
  57     "bl"
  58     "--boundary\n"
  59     "Content-type: text/html\n\n"
  60     "ah!";
  61
  62 class TestBridge : public ResourceLoaderBridge,
  63                    public base::SupportsWeakPtr<TestBridge> {
  64  public:
  65   TestBridge(const RequestInfo& info) :
  66     peer_(NULL),
  67     canceled_(false),
  68     url_(info.url) {
  69   }
  70
  71   ~TestBridge() override {}
  72
  73   // ResourceLoaderBridge implementation:
  74   void SetRequestBody(ResourceRequestBody* request_body) override {}
  75
  76   bool Start(RequestPeer* peer) override {
  77     EXPECT_FALSE(peer_);
  78     peer_ = peer;
  79     return true;
  80   }
  81
  82   void Cancel() override {
  83     EXPECT_FALSE(canceled_);
  84     canceled_ = true;
  85   }
  86
  87   void SetDefersLoading(bool value) override {}
  88
  89   void DidChangePriority(net::RequestPriority new_priority,
  90                          int intra_priority_value) override {}
  91
  92   bool AttachThreadedDataReceiver(
  93       blink::WebThreadedDataReceiver* threaded_data_receiver) override {
  94     NOTREACHED();
  95     return false;
  96   }
  97
  98   void SyncLoad(SyncLoadResponse* response) override {}
  99
 100   RequestPeer* peer() { return peer_; }
 101
 102   bool canceled() { return canceled_; }
 103
 104   const GURL& url() { return url_; }
 105
 106  private:
 107   RequestPeer* peer_;
 108   bool canceled_;
 109   GURL url_;
 110
 111   DISALLOW_COPY_AND_ASSIGN(TestBridge);
 112 };
 113
 114 class TestResourceDispatcher : public ResourceDispatcher {
 115  public:
 116   TestResourceDispatcher() : ResourceDispatcher(NULL) {}
 117   ~TestResourceDispatcher() override {}
 118
 119   // ResourceDispatcher implementation:
 120   ResourceLoaderBridge* CreateBridge(const RequestInfo& request_info) override {
 121     EXPECT_FALSE(bridge_.get());
 122     TestBridge* bridge = new TestBridge(request_info);
 123     bridge_ = bridge->AsWeakPtr();
 124     return bridge;
 125   }
 126
 127   TestBridge* bridge() { return bridge_.get(); }
 128
 129  private:
 130   base::WeakPtr<TestBridge> bridge_;
 131
 132   DISALLOW_COPY_AND_ASSIGN(TestResourceDispatcher);
 133 };
 134
 135 class TestWebURLLoaderClient : public blink::WebURLLoaderClient {
 136  public:
 137   TestWebURLLoaderClient(ResourceDispatcher* dispatcher)
 138       : loader_(new WebURLLoaderImpl(dispatcher)),
 139         expect_multipart_response_(false),
 140         delete_on_receive_redirect_(false),
 141         delete_on_receive_response_(false),
 142         delete_on_receive_data_(false),
 143         delete_on_finish_(false),
 144         delete_on_fail_(false),
 145         did_receive_redirect_(false),
 146         did_receive_response_(false),
 147         did_finish_(false) {
 148   }
 149
 150   virtual ~TestWebURLLoaderClient() {}
 151
 152   // blink::WebURLLoaderClient implementation:
 153   virtual void willSendRequest(
 154       blink::WebURLLoader* loader,
 155       blink::WebURLRequest& newRequest,
 156       const blink::WebURLResponse& redirectResponse) override {
 157     EXPECT_TRUE(loader_);
 158     EXPECT_EQ(loader_.get(), loader);
 159     // No test currently simulates mutiple redirects.
 160     EXPECT_FALSE(did_receive_redirect_);
 161     did_receive_redirect_ = true;
 162
 163     if (delete_on_receive_redirect_)
 164       loader_.reset();
 165   }
 166
 167   virtual void didSendData(blink::WebURLLoader* loader,
 168                            unsigned long long bytesSent,
 169                            unsigned long long totalBytesToBeSent) override {
 170     EXPECT_TRUE(loader_);
 171     EXPECT_EQ(loader_.get(), loader);
 172   }
 173
 174   virtual void didReceiveResponse(
 175       blink::WebURLLoader* loader,
 176       const blink::WebURLResponse& response) override {
 177     EXPECT_TRUE(loader_);
 178     EXPECT_EQ(loader_.get(), loader);
 179
 180     // Only multipart requests may receive multiple response headers.
 181     EXPECT_TRUE(expect_multipart_response_ || !did_receive_response_);
 182
 183     did_receive_response_ = true;
 184     response_ = response;
 185     if (delete_on_receive_response_)
 186       loader_.reset();
 187   }
 188
 189   virtual void didDownloadData(blink::WebURLLoader* loader,
 190                                int dataLength,
 191                                int encodedDataLength) override {
 192     EXPECT_TRUE(loader_);
 193     EXPECT_EQ(loader_.get(), loader);
 194   }
 195
 196   virtual void didReceiveData(blink::WebURLLoader* loader,
 197                               const char* data,
 198                               int dataLength,
 199                               int encodedDataLength) override {
 200     EXPECT_TRUE(loader_);
 201     EXPECT_EQ(loader_.get(), loader);
 202     // The response should have started, but must not have finished, or failed.
 203     EXPECT_TRUE(did_receive_response_);
 204     EXPECT_FALSE(did_finish_);
 205     EXPECT_EQ(net::OK, error_.reason);
 206     EXPECT_EQ("", error_.domain.utf8());
 207
 208     received_data_.append(data, dataLength);
 209
 210     if (delete_on_receive_data_)
 211       loader_.reset();
 212   }
 213
 214   virtual void didReceiveCachedMetadata(blink::WebURLLoader* loader,
 215                                         const char* data,
 216                                         int dataLength) override {
 217     EXPECT_EQ(loader_.get(), loader);
 218   }
 219
 220   virtual void didFinishLoading(blink::WebURLLoader* loader,
 221                                 double finishTime,
 222                                 int64_t totalEncodedDataLength) override {
 223     EXPECT_TRUE(loader_);
 224     EXPECT_EQ(loader_.get(), loader);
 225     EXPECT_TRUE(did_receive_response_);
 226     EXPECT_FALSE(did_finish_);
 227     did_finish_ = true;
 228
 229     if (delete_on_finish_)
 230       loader_.reset();
 231   }
 232
 233   virtual void didFail(blink::WebURLLoader* loader,
 234                        const blink::WebURLError& error) override {
 235     EXPECT_TRUE(loader_);
 236     EXPECT_EQ(loader_.get(), loader);
 237     EXPECT_FALSE(did_finish_);
 238     error_ = error;
 239
 240     if (delete_on_fail_)
 241       loader_.reset();
 242   }
 243
 244   WebURLLoaderImpl* loader() { return loader_.get(); }
 245   void DeleteLoader() {
 246     loader_.reset();
 247   }
 248
 249   void set_expect_multipart_response() { expect_multipart_response_ = true; }
 250
 251   void set_delete_on_receive_redirect() { delete_on_receive_redirect_ = true; }
 252   void set_delete_on_receive_response() { delete_on_receive_response_ = true; }
 253   void set_delete_on_receive_data() { delete_on_receive_data_ = true; }
 254   void set_delete_on_finish() { delete_on_finish_ = true; }
 255   void set_delete_on_fail() { delete_on_fail_ = true; }
 256
 257   bool did_receive_redirect() const { return did_receive_redirect_; }
 258   bool did_receive_response() const { return did_receive_response_; }
 259   const std::string& received_data() const { return received_data_; }
 260   bool did_finish() const { return did_finish_; }
 261   const blink::WebURLError& error() const { return error_; }
 262   const blink::WebURLResponse& response() const { return response_; }
 263
 264  private:
 265   scoped_ptr<WebURLLoaderImpl> loader_;
 266
 267   bool expect_multipart_response_;
 268
 269   bool delete_on_receive_redirect_;
 270   bool delete_on_receive_response_;
 271   bool delete_on_receive_data_;
 272   bool delete_on_finish_;
 273   bool delete_on_fail_;
 274
 275   bool did_receive_redirect_;
 276   bool did_receive_response_;
 277   std::string received_data_;
 278   bool did_finish_;
 279   blink::WebURLError error_;
 280   blink::WebURLResponse response_;
 281
 282   DISALLOW_COPY_AND_ASSIGN(TestWebURLLoaderClient);
 283 };
 284
 285 class WebURLLoaderImplTest : public testing::Test {
 286  public:
 287   explicit WebURLLoaderImplTest() : client_(&dispatcher_) {}
 288   ~WebURLLoaderImplTest() override {}
 289
 290   void DoStartAsyncRequest() {
 291     blink::WebURLRequest request;
 292     request.initialize();
 293     request.setURL(GURL(kTestURL));
 294     client()->loader()->loadAsynchronously(request, client());
 295     ASSERT_TRUE(bridge());
 296     ASSERT_TRUE(peer());
 297   }
 298
 299   void DoReceiveRedirect() {
 300     EXPECT_FALSE(client()->did_receive_redirect());
 301     net::RedirectInfo redirect_info;
 302     redirect_info.status_code = 302;
 303     redirect_info.new_method = "GET";
 304     redirect_info.new_url = GURL(kTestURL);
 305     redirect_info.new_first_party_for_cookies = GURL(kTestURL);
 306     peer()->OnReceivedRedirect(redirect_info,
 307                                content::ResourceResponseInfo());
 308     EXPECT_TRUE(client()->did_receive_redirect());
 309   }
 310
 311   void DoReceiveResponse() {
 312     EXPECT_FALSE(client()->did_receive_response());
 313     peer()->OnReceivedResponse(content::ResourceResponseInfo());
 314     EXPECT_TRUE(client()->did_receive_response());
 315   }
 316
 317   // Assumes it is called only once for a request.
 318   void DoReceiveData() {
 319     EXPECT_EQ("", client()->received_data());
 320     peer()->OnReceivedData(kTestData, strlen(kTestData), strlen(kTestData));
 321     EXPECT_EQ(kTestData, client()->received_data());
 322   }
 323
 324   void DoCompleteRequest() {
 325     EXPECT_FALSE(client()->did_finish());
 326     peer()->OnCompletedRequest(net::OK, false, false, "", base::TimeTicks(),
 327                                strlen(kTestData));
 328     EXPECT_TRUE(client()->did_finish());
 329     // There should be no error.
 330     EXPECT_EQ(net::OK, client()->error().reason);
 331     EXPECT_EQ("", client()->error().domain.utf8());
 332   }
 333
 334   void DoFailRequest() {
 335     EXPECT_FALSE(client()->did_finish());
 336     peer()->OnCompletedRequest(net::ERR_FAILED, false, false, "",
 337                                base::TimeTicks(), strlen(kTestData));
 338     EXPECT_FALSE(client()->did_finish());
 339     EXPECT_EQ(net::ERR_FAILED, client()->error().reason);
 340     EXPECT_EQ(net::kErrorDomain, client()->error().domain.utf8());
 341   }
 342
 343   void DoReceiveResponseFtp() {
 344     EXPECT_FALSE(client()->did_receive_response());
 345     content::ResourceResponseInfo response_info;
 346     response_info.mime_type = kFtpDirMimeType;
 347     peer()->OnReceivedResponse(response_info);
 348     EXPECT_TRUE(client()->did_receive_response());
 349   }
 350
 351   void DoReceiveDataFtp() {
 352     peer()->OnReceivedData(kFtpDirListing, strlen(kFtpDirListing),
 353                            strlen(kFtpDirListing));
 354     // The FTP delegate should modify the data the client sees.
 355     EXPECT_NE(kFtpDirListing, client()->received_data());
 356   }
 357
 358   void DoReceiveResponseMultipart() {
 359     EXPECT_FALSE(client()->did_receive_response());
 360     content::ResourceResponseInfo response_info;
 361     response_info.headers = new net::HttpResponseHeaders(
 362         net::HttpUtil::AssembleRawHeaders(kMultipartResponseHeaders,
 363                                           strlen(kMultipartResponseHeaders)));
 364     response_info.mime_type = kMultipartResponseMimeType;
 365     peer()->OnReceivedResponse(response_info);
 366     EXPECT_TRUE(client()->did_receive_response());
 367   }
 368
 369   void DoReceiveDataMultipart() {
 370     peer()->OnReceivedData(kMultipartResponse, strlen(kMultipartResponse),
 371                            strlen(kMultipartResponse));
 372     // Multipart delegate should modify the data the client sees.
 373     EXPECT_NE(kMultipartResponse, client()->received_data());
 374   }
 375
 376   TestWebURLLoaderClient* client() { return &client_; }
 377   TestBridge* bridge() { return dispatcher_.bridge(); }
 378   RequestPeer* peer() { return bridge()->peer(); }
 379   base::MessageLoop* message_loop() { return &message_loop_; }
 380
 381  private:
 382   TestResourceDispatcher dispatcher_;
 383   TestWebURLLoaderClient client_;
 384
 385   base::MessageLoop message_loop_;
 386 };
 387
 388 TEST_F(WebURLLoaderImplTest, Success) {
 389   DoStartAsyncRequest();
 390   DoReceiveResponse();
 391   DoReceiveData();
 392   DoCompleteRequest();
 393   EXPECT_FALSE(bridge()->canceled());
 394   EXPECT_EQ(kTestData, client()->received_data());
 395 }
 396
 397 TEST_F(WebURLLoaderImplTest, Redirect) {
 398   DoStartAsyncRequest();
 399   DoReceiveRedirect();
 400   DoReceiveResponse();
 401   DoReceiveData();
 402   DoCompleteRequest();
 403   EXPECT_FALSE(bridge()->canceled());
 404   EXPECT_EQ(kTestData, client()->received_data());
 405 }
 406
 407 TEST_F(WebURLLoaderImplTest, Failure) {
 408   DoStartAsyncRequest();
 409   DoReceiveResponse();
 410   DoReceiveData();
 411   DoFailRequest();
 412   EXPECT_FALSE(bridge()->canceled());
 413 }
 414
 415 // The client may delete the WebURLLoader during any callback from the loader.
 416 // These tests make sure that doesn't result in a crash.
 417 TEST_F(WebURLLoaderImplTest, DeleteOnReceiveRedirect) {
 418   client()->set_delete_on_receive_redirect();
 419   DoStartAsyncRequest();
 420   DoReceiveRedirect();
 421   EXPECT_FALSE(bridge());
 422 }
 423
 424 TEST_F(WebURLLoaderImplTest, DeleteOnReceiveResponse) {
 425   client()->set_delete_on_receive_response();
 426   DoStartAsyncRequest();
 427   DoReceiveResponse();
 428   EXPECT_FALSE(bridge());
 429 }
 430
 431 TEST_F(WebURLLoaderImplTest, DeleteOnReceiveData) {
 432   client()->set_delete_on_receive_data();
 433   DoStartAsyncRequest();
 434   DoReceiveResponse();
 435   DoReceiveData();
 436   EXPECT_FALSE(bridge());
 437 }
 438
 439 TEST_F(WebURLLoaderImplTest, DeleteOnFinish) {
 440   client()->set_delete_on_finish();
 441   DoStartAsyncRequest();
 442   DoReceiveResponse();
 443   DoReceiveData();
 444   DoCompleteRequest();
 445   EXPECT_FALSE(bridge());
 446 }
 447
 448 TEST_F(WebURLLoaderImplTest, DeleteOnFail) {
 449   client()->set_delete_on_fail();
 450   DoStartAsyncRequest();
 451   DoReceiveResponse();
 452   DoReceiveData();
 453   DoFailRequest();
 454   EXPECT_FALSE(bridge());
 455 }
 456
 457 TEST_F(WebURLLoaderImplTest, DeleteBeforeResponseDataURL) {
 458   blink::WebURLRequest request;
 459   request.initialize();
 460   request.setURL(GURL("data:text/html;charset=utf-8,blah!"));
 461   client()->loader()->loadAsynchronously(request, client());
 462   client()->DeleteLoader();
 463   message_loop()->RunUntilIdle();
 464   EXPECT_FALSE(client()->did_receive_response());
 465   EXPECT_FALSE(bridge());
 466 }
 467
 468 // Data URL tests.
 469
 470 TEST_F(WebURLLoaderImplTest, DataURL) {
 471   blink::WebURLRequest request;
 472   request.initialize();
 473   request.setURL(GURL("data:text/html;charset=utf-8,blah!"));
 474   client()->loader()->loadAsynchronously(request, client());
 475   message_loop()->RunUntilIdle();
 476   EXPECT_EQ("blah!", client()->received_data());
 477   EXPECT_TRUE(client()->did_finish());
 478   EXPECT_EQ(net::OK, client()->error().reason);
 479   EXPECT_EQ("", client()->error().domain.utf8());
 480 }
 481
 482 TEST_F(WebURLLoaderImplTest, DataURLDeleteOnReceiveResponse) {
 483   blink::WebURLRequest request;
 484   request.initialize();
 485   request.setURL(GURL("data:text/html;charset=utf-8,blah!"));
 486   client()->set_delete_on_receive_response();
 487   client()->loader()->loadAsynchronously(request, client());
 488   message_loop()->RunUntilIdle();
 489   EXPECT_TRUE(client()->did_receive_response());
 490   EXPECT_EQ("", client()->received_data());
 491   EXPECT_FALSE(client()->did_finish());
 492   EXPECT_FALSE(bridge());
 493 }
 494
 495 TEST_F(WebURLLoaderImplTest, DataURLDeleteOnReceiveData) {
 496   blink::WebURLRequest request;
 497   request.initialize();
 498   request.setURL(GURL("data:text/html;charset=utf-8,blah!"));
 499   client()->set_delete_on_receive_data();
 500   client()->loader()->loadAsynchronously(request, client());
 501   message_loop()->RunUntilIdle();
 502   EXPECT_TRUE(client()->did_receive_response());
 503   EXPECT_EQ("blah!", client()->received_data());
 504   EXPECT_FALSE(client()->did_finish());
 505   EXPECT_FALSE(bridge());
 506 }
 507
 508 TEST_F(WebURLLoaderImplTest, DataURLDeleteOnFinisha) {
 509   blink::WebURLRequest request;
 510   request.initialize();
 511   request.setURL(GURL("data:text/html;charset=utf-8,blah!"));
 512   client()->set_delete_on_finish();
 513   client()->loader()->loadAsynchronously(request, client());
 514   message_loop()->RunUntilIdle();
 515   EXPECT_TRUE(client()->did_receive_response());
 516   EXPECT_EQ("blah!", client()->received_data());
 517   EXPECT_TRUE(client()->did_finish());
 518   EXPECT_FALSE(bridge());
 519 }
 520
 521 // FTP integration tests.  These are focused more on safe deletion than correct
 522 // parsing of FTP responses.
 523
 524 TEST_F(WebURLLoaderImplTest, Ftp) {
 525   DoStartAsyncRequest();
 526   DoReceiveResponseFtp();
 527   DoReceiveDataFtp();
 528   DoCompleteRequest();
 529   EXPECT_FALSE(bridge()->canceled());
 530 }
 531
 532 TEST_F(WebURLLoaderImplTest, FtpDeleteOnReceiveResponse) {
 533   client()->set_delete_on_receive_response();
 534   DoStartAsyncRequest();
 535   DoReceiveResponseFtp();
 536
 537   // No data should have been received.
 538   EXPECT_EQ("", client()->received_data());
 539   EXPECT_FALSE(bridge());
 540 }
 541
 542 TEST_F(WebURLLoaderImplTest, FtpDeleteOnReceiveFirstData) {
 543   client()->set_delete_on_receive_data();
 544   DoStartAsyncRequest();
 545   // Some data is sent in ReceiveResponse for FTP requests, so the bridge should
 546   // be deleted here.
 547   DoReceiveResponseFtp();
 548
 549   EXPECT_NE("", client()->received_data());
 550   EXPECT_FALSE(bridge());
 551 }
 552
 553 TEST_F(WebURLLoaderImplTest, FtpDeleteOnReceiveMoreData) {
 554   DoStartAsyncRequest();
 555   DoReceiveResponseFtp();
 556   DoReceiveDataFtp();
 557
 558   // Directory listings are only parsed once the request completes, so this will
 559   // cancel in DoReceiveDataFtp, before the request finishes.
 560   client()->set_delete_on_receive_data();
 561   peer()->OnCompletedRequest(net::OK, false, false, "", base::TimeTicks(),
 562                               strlen(kTestData));
 563   EXPECT_FALSE(client()->did_finish());
 564
 565   EXPECT_FALSE(bridge());
 566 }
 567
 568 TEST_F(WebURLLoaderImplTest, FtpDeleteOnFinish) {
 569   client()->set_delete_on_finish();
 570   DoStartAsyncRequest();
 571   DoReceiveResponseFtp();
 572   DoReceiveDataFtp();
 573   DoCompleteRequest();
 574   EXPECT_FALSE(bridge());
 575 }
 576
 577 TEST_F(WebURLLoaderImplTest, FtpDeleteOnFail) {
 578   client()->set_delete_on_fail();
 579   DoStartAsyncRequest();
 580   DoReceiveResponseFtp();
 581   DoReceiveDataFtp();
 582   DoFailRequest();
 583   EXPECT_FALSE(bridge());
 584 }
 585
 586 // Multipart integration tests.  These are focused more on safe deletion than
 587 // correct parsing of Multipart responses.
 588
 589 TEST_F(WebURLLoaderImplTest, Multipart) {
 590   client()->set_expect_multipart_response();
 591   DoStartAsyncRequest();
 592   DoReceiveResponseMultipart();
 593   DoReceiveDataMultipart();
 594   DoCompleteRequest();
 595   EXPECT_EQ(kTestData, client()->received_data());
 596   EXPECT_FALSE(bridge()->canceled());
 597 }
 598
 599 TEST_F(WebURLLoaderImplTest, MultipartDeleteOnReceiveFirstResponse) {
 600   client()->set_expect_multipart_response();
 601   client()->set_delete_on_receive_response();
 602   DoStartAsyncRequest();
 603   DoReceiveResponseMultipart();
 604   EXPECT_EQ("", client()->received_data());
 605   EXPECT_FALSE(bridge());
 606 }
 607
 608 TEST_F(WebURLLoaderImplTest, MultipartDeleteOnReceiveSecondResponse) {
 609   client()->set_expect_multipart_response();
 610   DoStartAsyncRequest();
 611   DoReceiveResponseMultipart();
 612   client()->set_delete_on_receive_response();
 613   DoReceiveDataMultipart();
 614   EXPECT_EQ("", client()->received_data());
 615   EXPECT_FALSE(bridge());
 616 }
 617
 618 TEST_F(WebURLLoaderImplTest, MultipartDeleteOnReceiveFirstData) {
 619   client()->set_expect_multipart_response();
 620   client()->set_delete_on_receive_data();
 621   DoStartAsyncRequest();
 622   DoReceiveResponseMultipart();
 623   DoReceiveDataMultipart();
 624   EXPECT_EQ("bl", client()->received_data());
 625   EXPECT_FALSE(bridge());
 626 }
 627
 628 TEST_F(WebURLLoaderImplTest, MultipartDeleteOnReceiveMoreData) {
 629   client()->set_expect_multipart_response();
 630   DoStartAsyncRequest();
 631   DoReceiveResponseMultipart();
 632   DoReceiveDataMultipart();
 633   // For multipart responses, the delegate may send some data when notified
 634   // of a request completing.
 635   client()->set_delete_on_receive_data();
 636   peer()->OnCompletedRequest(net::OK, false, false, "", base::TimeTicks(),
 637                               strlen(kTestData));
 638   EXPECT_FALSE(client()->did_finish());
 639   EXPECT_EQ(kTestData, client()->received_data());
 640   EXPECT_FALSE(bridge());
 641 }
 642
 643 TEST_F(WebURLLoaderImplTest, MultipartDeleteFinish) {
 644   client()->set_expect_multipart_response();
 645   client()->set_delete_on_finish();
 646   DoStartAsyncRequest();
 647   DoReceiveResponseMultipart();
 648   DoReceiveDataMultipart();
 649   DoCompleteRequest();
 650   EXPECT_EQ(kTestData, client()->received_data());
 651   EXPECT_FALSE(bridge());
 652 }
 653
 654 TEST_F(WebURLLoaderImplTest, MultipartDeleteFail) {
 655   client()->set_expect_multipart_response();
 656   client()->set_delete_on_fail();
 657   DoStartAsyncRequest();
 658   DoReceiveResponseMultipart();
 659   DoReceiveDataMultipart();
 660   DoFailRequest();
 661   EXPECT_FALSE(bridge());
 662 }
 663
 664 // PlzNavigate: checks that the stream override parameters provided on
 665 // navigation commit are properly applied.
 666 TEST_F(WebURLLoaderImplTest, BrowserSideNavigationCommit) {
 667   // Initialize the request and the stream override.
 668   const GURL kStreamURL = GURL("http://bar");
 669   const std::string kMimeType = "text/html";
 670   blink::WebURLRequest request;
 671   request.initialize();
 672   request.setURL(GURL(kTestURL));
 673   request.setFrameType(blink::WebURLRequest::FrameTypeTopLevel);
 674   request.setRequestContext(blink::WebURLRequest::RequestContextFrame);
 675   scoped_ptr<StreamOverrideParameters> stream_override(
 676       new StreamOverrideParameters());
 677   stream_override->stream_url = kStreamURL;
 678   stream_override->response.mime_type = kMimeType;
 679   RequestExtraData* extra_data = new RequestExtraData();
 680   extra_data->set_stream_override(stream_override.Pass());
 681   request.setExtraData(extra_data);
 682   CommandLine::ForCurrentProcess()->AppendSwitch(
 683       switches::kEnableBrowserSideNavigation);
 684
 685   client()->loader()->loadAsynchronously(request, client());
 686
 687   // The stream url should have been requestead instead of the request url.
 688   ASSERT_TRUE(bridge());
 689   ASSERT_TRUE(peer());
 690   EXPECT_EQ(kStreamURL, bridge()->url());
 691
 692   EXPECT_FALSE(client()->did_receive_response());
 693   peer()->OnReceivedResponse(content::ResourceResponseInfo());
 694   EXPECT_TRUE(client()->did_receive_response());
 695
 696   // The response info should have been overriden.
 697   ASSERT_FALSE(client()->response().isNull());
 698   EXPECT_EQ(kMimeType, client()->response().mimeType().latin1());
 699
 700   DoReceiveData();
 701   DoCompleteRequest();
 702   EXPECT_FALSE(bridge()->canceled());
 703   EXPECT_EQ(kTestData, client()->received_data());
 704 }
 705
 706 }  // namespace
 707 }  // namespace content