The cross-origin checks in the multibuffer code are not sufficient, as they only trigger when a red…

media/blink/multibuffer_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 <stddef.h>
 #include <stdint.h>
 
 #include "base/bind.h"
 #include "base/macros.h"
 #include "base/message_loop/message_loop.h"
@@ skipping 36 matching lines @@
 
 class TestMultiBufferDataProvider : public ResourceMultiBufferDataProvider {
  public:
   TestMultiBufferDataProvider(UrlData* url_data, MultiBuffer::BlockId pos)
       : ResourceMultiBufferDataProvider(url_data, pos), loading_(false) {
     CHECK(test_data_providers.insert(this).second);
   }
   ~TestMultiBufferDataProvider() override {
     CHECK_EQ(static_cast<size_t>(1), test_data_providers.erase(this));
   }
+  void SetLoadingToFalse() {
+    // Check that we have not been destroyed first.
+    if (test_data_providers.find(this) != test_data_providers.end()) {
+      loading_ = false;
+    }
+  }
   void Start() override {
     // Create a mock active loader.
     // Keep track of active loading state via loadAsynchronously() and cancel().
     NiceMock<MockWebURLLoader>* url_loader = new NiceMock<MockWebURLLoader>();
-    ON_CALL(*url_loader, cancel()).WillByDefault(Assign(&loading_, false));
+    ON_CALL(*url_loader, cancel())
+        .WillByDefault(
+            Invoke(this, &TestMultiBufferDataProvider::SetLoadingToFalse));
     loading_ = true;
     active_loader_.reset(
         new ActiveLoader(scoped_ptr<WebURLLoader>(url_loader)));
     if (!on_start_.is_null()) {
       on_start_.Run();
     }
   }
 
   bool loading() const { return loading_; }
   void RunOnStart(base::Closure cb) { on_start_ = cb; }
@@ skipping 98 matching lines @@
   MOCK_METHOD2(AddBufferedByteRange, void(int64_t start, int64_t end));
 
  private:
   DISALLOW_COPY_AND_ASSIGN(MockBufferedDataSourceHost);
 };
 
 class MockMultibufferDataSource : public MultibufferDataSource {
  public:
   MockMultibufferDataSource(
       const GURL& url,
+      UrlData::CORSMode cors_mode,
       const scoped_refptr<base::SingleThreadTaskRunner>& task_runner,
       linked_ptr<UrlIndex> url_index,
       WebLocalFrame* frame,
       BufferedDataSourceHost* host)
       : MultibufferDataSource(
             url,
-            UrlData::CORS_UNSPECIFIED,
+            cors_mode,
             task_runner,
             url_index,
             frame,
             new media::MediaLog(),
             host,
             base::Bind(&MockMultibufferDataSource::set_downloading,
                        base::Unretained(this))),
         downloading_(false) {}
 
   bool downloading() { return downloading_; }
@@ skipping 27 matching lines @@
     view_->setMainFrame(frame_);
   }
 
   virtual ~MultibufferDataSourceTest() {
     view_->close();
     frame_->close();
   }
 
   MOCK_METHOD1(OnInitialize, void(bool));
 
-  void Initialize(const char* url, bool expected) {
+  void InitializeWithCORS(const char* url,
+                          bool expected,
+                          UrlData::CORSMode cors_mode) {
     GURL gurl(url);
     data_source_.reset(new MockMultibufferDataSource(
-        gurl, message_loop_.task_runner(), url_index_,
+        gurl, cors_mode, message_loop_.task_runner(), url_index_,
         view_->mainFrame()->toWebLocalFrame(), &host_));
     data_source_->SetPreload(preload_);
 
     response_generator_.reset(new TestResponseGenerator(gurl, kFileSize));
     EXPECT_CALL(*this, OnInitialize(expected));
     data_source_->Initialize(base::Bind(
         &MultibufferDataSourceTest::OnInitialize, base::Unretained(this)));
     message_loop_.RunUntilIdle();
 
     // Not really loading until after OnInitialize is called.
     EXPECT_EQ(data_source_->downloading(), false);
   }
 
+  void Initialize(const char* url, bool expected) {
+    InitializeWithCORS(url, expected, UrlData::CORS_UNSPECIFIED);
+  }
+
   // Helper to initialize tests with a valid 200 response.
   void InitializeWith200Response() {
     Initialize(kHttpUrl, true);
 
     EXPECT_CALL(host_, SetTotalBytes(response_generator_->content_length()));
     Respond(response_generator_->Generate200());
 
     EXPECT_CALL(host_, AddBufferedByteRange(0, kDataSize));
     ReceiveData(kDataSize);
   }
@@ skipping 103 matching lines @@
     ReceiveData(kDataSize);
     FinishLoading();
     Stop();
   }
 
   void ExecuteMixedResponseFailureTest(const WebURLResponse& response1,
                                        const WebURLResponse& response2) {
     EXPECT_CALL(host_, SetTotalBytes(kFileSize));
     EXPECT_CALL(host_, AddBufferedByteRange(0, kDataSize));
     EXPECT_CALL(*this, ReadCallback(kDataSize));
-    EXPECT_CALL(*this, ReadCallback(media::DataSource::kReadError));
+    // Stop() will also cause the readback to be called with kReadError, but
+    // we want to make sure it was called before Stop().
+    bool failed_ = false;
+    EXPECT_CALL(*this, ReadCallback(media::DataSource::kReadError))
+        .WillOnce(Assign(&failed_, true));
 
     Respond(response1);
     ReceiveData(kDataSize);
     ReadAt(0);
     EXPECT_TRUE(loading());
 
     FinishLoading();
     Restart();
     ReadAt(kDataSize);
     Respond(response2);
+    EXPECT_TRUE(failed_);
     Stop();
   }
 
   void CheckCapacityDefer() {
     EXPECT_EQ(2 << 20, preload_low());
     EXPECT_EQ(3 << 20, preload_high());
   }
 
   void CheckReadThenDefer() {
     EXPECT_EQ(0, preload_low());
@@ skipping 370 matching lines @@
       response_generator_->GeneratePartial206(0, kDataSize - 1);
   response1.setWasFetchedViaServiceWorker(true);
   response1.setOriginalURLViaServiceWorker(GURL(kHttpDifferentOriginUrl));
   WebURLResponse response2 =
       response_generator_->GeneratePartial206(kDataSize, kDataSize * 2 - 1);
   // The origin URL of response1 and response2 are different. So an error should
   // occur.
   ExecuteMixedResponseFailureTest(response1, response2);
 }
 
+TEST_F(MultibufferDataSourceTest,
+       Http_MixedResponse_ServiceWorkerProxiedAndDifferentOriginResponseCORS) {
+  InitializeWithCORS(kHttpUrl, true, UrlData::CORS_ANONYMOUS);
+  WebURLResponse response1 =
+      response_generator_->GeneratePartial206(0, kDataSize - 1);
+  response1.setWasFetchedViaServiceWorker(true);
+  response1.setOriginalURLViaServiceWorker(GURL(kHttpDifferentOriginUrl));
+  WebURLResponse response2 =
+      response_generator_->GeneratePartial206(kDataSize, kDataSize * 2 - 1);
+  // The origin URL of response1 and response2 are different, but a CORS check
+  // has been passed for each request, so expect success.
+  ExecuteMixedResponseSuccessTest(response1, response2);
+}
+
 TEST_F(MultibufferDataSourceTest, File_Retry) {
   InitializeWithFileResponse();
 
   // Read to advance our position.
   EXPECT_CALL(*this, ReadCallback(kDataSize));
   ReadAt(0);
 
   // Issue a pending read but terminate the connection to force a retry.
   ReadAt(kDataSize);
   FinishLoading();
@@ skipping 175 matching lines @@
   EXPECT_CALL(host_,
               AddBufferedByteRange(kDataSize, kDataSize + kDataSize / 2));
   ReceiveData(kDataSize / 2);
   EXPECT_CALL(host_, AddBufferedByteRange(0, kDataSize * 2));
   ReceiveData(kDataSize / 2);
 
   EXPECT_TRUE(data_source_->downloading());
 
   StrictMock<MockBufferedDataSourceHost> host2;
   MockMultibufferDataSource source2(
-      GURL(kHttpUrl), message_loop_.task_runner(), url_index_,
-      view_->mainFrame()->toWebLocalFrame(), &host2);
+      GURL(kHttpUrl), UrlData::CORS_UNSPECIFIED, message_loop_.task_runner(),
+      url_index_, view_->mainFrame()->toWebLocalFrame(), &host2);
   source2.SetPreload(preload_);
 
   EXPECT_CALL(*this, OnInitialize(true));
 
   // This call would not be expected if we were not sharing data.
   EXPECT_CALL(host2, SetTotalBytes(response_generator_->content_length()));
   source2.Initialize(base::Bind(&MultibufferDataSourceTest::OnInitialize,
                                 base::Unretained(this)));
   message_loop_.RunUntilIdle();
 
@@ skipping 272 matching lines @@
     bytes_received += kDataSize;
   }
   EXPECT_GT(bytes_received, 0);
   EXPECT_LT(bytes_received + kDataSize, kFileSize);
   EXPECT_FALSE(active_loader_allownull());
 }
 
 TEST_F(MultibufferDataSourceTest, SeekPastEOF) {
   GURL gurl(kHttpUrl);
   data_source_.reset(new MockMultibufferDataSource(
-      gurl, message_loop_.task_runner(), url_index_,
+      gurl, UrlData::CORS_UNSPECIFIED, message_loop_.task_runner(), url_index_,
       view_->mainFrame()->toWebLocalFrame(), &host_));
   data_source_->SetPreload(preload_);
 
   response_generator_.reset(new TestResponseGenerator(gurl, kDataSize + 1));
   EXPECT_CALL(*this, OnInitialize(true));
   data_source_->Initialize(base::Bind(&MultibufferDataSourceTest::OnInitialize,
                                       base::Unretained(this)));
   message_loop_.RunUntilIdle();
 
   // Not really loading until after OnInitialize is called.
@@ skipping 90 matching lines @@
   EXPECT_CALL(host_, AddBufferedByteRange(0, kDataSize * 2));
   FinishLoading();
 
   // Done loading, now we should know the length.
   EXPECT_TRUE(data_source_->GetSize(&len));
   EXPECT_EQ(kDataSize, len);
   Stop();
 }
 
 }  // namespace media