Check the response URL origin in BufferedDataSource to avoid mixing cross-origin responses.

media/blink/buffered_data_source_unittest.cc

 // Copyright 2013 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 "base/bind.h"
 #include "base/message_loop/message_loop.h"
 #include "base/run_loop.h"
 #include "media/base/media_log.h"
 #include "media/base/mock_filters.h"
 #include "media/base/test_helpers.h"
@@ skipping 90 matching lines @@
 
   DISALLOW_COPY_AND_ASSIGN(MockBufferedDataSource);
 };
 
 static const int64 kFileSize = 5000000;
 static const int64 kFarReadPosition = 4000000;
 static const int kDataSize = 1024;
 
 static const char kHttpUrl[] = "http://localhost/foo.webm";
 static const char kFileUrl[] = "file:///tmp/bar.webm";
+static const char kHttpOtherUrl[] = "http://127.0.0.1/foo.webm";

[falken, 2015/07/02 01:04:08]

The point is this url has a different origin than kHttpUrl. So
kHttpOtherOriginUrl may be better.

[horo, 2015/07/02 03:10:49]

Done.

 
 class BufferedDataSourceTest : public testing::Test {
  public:
   BufferedDataSourceTest()
       : view_(WebView::create(NULL)),
         frame_(
             WebLocalFrame::create(blink::WebTreeScopeType::Document, &client_)),
         preload_(BufferedDataSource::AUTO) {
     view_->setMainFrame(frame_);
   }
@@ skipping 92 matching lines @@
 
   MOCK_METHOD1(ReadCallback, void(int size));
 
   void ReadAt(int64 position) {
     data_source_->Read(position, kDataSize, buffer_,
                        base::Bind(&BufferedDataSourceTest::ReadCallback,
                                   base::Unretained(this)));
     message_loop_.RunUntilIdle();
   }
 
+  void ExecuteMixedResponseSuccessTest(const WebURLResponse& response1,
+                                       const WebURLResponse& response2) {
+    EXPECT_CALL(host_, SetTotalBytes(kFileSize));
+    EXPECT_CALL(host_, AddBufferedByteRange(kDataSize, kDataSize * 2 - 1));
+    EXPECT_CALL(host_, AddBufferedByteRange(0, kDataSize - 1));
+    EXPECT_CALL(*this, ReadCallback(kDataSize)).Times(2);
+
+    Respond(response1);
+    ReadAt(0);
+    ReceiveData(kDataSize);
+    EXPECT_TRUE(data_source_->loading());
+
+    ExpectCreateResourceLoader();
+    FinishLoading();
+    ReadAt(kDataSize);
+    Respond(response2);
+    ReceiveData(kDataSize);
+    FinishLoading();
+    Stop();
+  }
+
+  void ExecuteMixedResponseFailureTest(const WebURLResponse& response1,
+                                       const WebURLResponse& response2) {
+    EXPECT_CALL(host_, SetTotalBytes(kFileSize));
+    EXPECT_CALL(host_, AddBufferedByteRange(0, kDataSize - 1));
+    EXPECT_CALL(*this, ReadCallback(kDataSize));
+    EXPECT_CALL(*this, ReadCallback(media::DataSource::kReadError));
+
+    Respond(response1);
+    ReadAt(0);
+    ReceiveData(kDataSize);
+    EXPECT_TRUE(data_source_->loading());
+
+    ExpectCreateResourceLoader();
+    FinishLoading();
+    ReadAt(kDataSize);
+    Respond(response2);
+    EXPECT_FALSE(data_source_->loading());
+    Stop();
+  }
+
   // Accessors for private variables on |data_source_|.
   BufferedResourceLoader* loader() {
     return data_source_->loader_.get();
   }
   ActiveLoader* active_loader() { return loader()->active_loader_.get(); }
   WebURLLoader* url_loader() {
     return loader()->active_loader_->loader_.get();
   }
 
   BufferedDataSource::Preload preload() { return data_source_->preload_; }
@@ skipping 203 matching lines @@
                        &MockBufferedDataSource::CreateMockResourceLoader)));
   loader()->didFail(url_loader(), response_generator_->GenerateError());
   run_loop.Run();
   Respond(response_generator_->Generate206(kDataSize));
   ReceiveData(kDataSize);
   FinishLoading();
   EXPECT_FALSE(data_source_->loading());
   Stop();
 }
 
+TEST_F(BufferedDataSourceTest, Http_PartialResponse) {
+  Initialize(kHttpUrl, true);
+  WebURLResponse response1 =
+      response_generator_->GeneratePartial206(0, kDataSize - 1);
+  WebURLResponse response2 =
+      response_generator_->GeneratePartial206(kDataSize, kDataSize * 2 - 1);
+  ExecuteMixedResponseSuccessTest(response1, response2);
+}
+
+TEST_F(BufferedDataSourceTest, Http_MixedResponse_RedirectedResponse) {
+  Initialize(kHttpUrl, true);
+  WebURLResponse response1 =
+      response_generator_->GeneratePartial206(0, kDataSize - 1);
+  WebURLResponse response2 =
+      response_generator_->GeneratePartial206(kDataSize, kDataSize * 2 - 1);
+  response2.setURL(GURL(kHttpOtherUrl));
+  ExecuteMixedResponseFailureTest(response1, response2);
+}
+
+TEST_F(BufferedDataSourceTest,
+       Http_MixedResponse_ServiceWorkerGeneratedResponseAndNormalResponse) {
+  Initialize(kHttpUrl, true);
+  WebURLResponse response1 =
+      response_generator_->GeneratePartial206(0, kDataSize - 1);
+  response1.setWasFetchedViaServiceWorker(true);
+  WebURLResponse response2 =
+      response_generator_->GeneratePartial206(kDataSize, kDataSize * 2 - 1);
+  ExecuteMixedResponseFailureTest(response1, response2);
+}
+
+TEST_F(BufferedDataSourceTest,
+       Http_MixedResponse_ServiceWorkerProxiedResponseAndNormalResponse) {
+  Initialize(kHttpUrl, true);
+  WebURLResponse response1 =
+      response_generator_->GeneratePartial206(0, kDataSize - 1);
+  response1.setWasFetchedViaServiceWorker(true);
+  response1.setOriginalURLViaServiceWorker(GURL(kHttpUrl));
+  WebURLResponse response2 =
+      response_generator_->GeneratePartial206(kDataSize, kDataSize * 2 - 1);
+  ExecuteMixedResponseSuccessTest(response1, response2);
+}
+
+TEST_F(BufferedDataSourceTest,
+       Http_MixedResponse_ServiceWorkerRedirectedResponseAndNormalResponse) {
+  Initialize(kHttpUrl, true);
+  WebURLResponse response1 =
+      response_generator_->GeneratePartial206(0, kDataSize - 1);
+  response1.setWasFetchedViaServiceWorker(true);
+  response1.setOriginalURLViaServiceWorker(GURL(kHttpOtherUrl));
+  WebURLResponse response2 =
+      response_generator_->GeneratePartial206(kDataSize, kDataSize * 2 - 1);
+  ExecuteMixedResponseFailureTest(response1, response2);
+}
+
 TEST_F(BufferedDataSourceTest, File_Retry) {
   InitializeWithFileResponse();
 
   // Read to advance our position.
   EXPECT_CALL(*this, ReadCallback(kDataSize));
   ReadAt(0);
   ReceiveData(kDataSize);
 
   // Issue a pending read but terminate the connection to force a retry.
   ReadAt(kDataSize);
@@ skipping 388 matching lines @@
   // Read a bit from the beginning.
   ReadAt(0);
   EXPECT_CALL(*this, ReadCallback(kDataSize));
   EXPECT_CALL(host_, AddBufferedByteRange(0, kDataSize - 1));
   ReceiveData(kDataSize);
 
   EXPECT_FALSE(active_loader());
 }
 
 }  // namespace media