Relax cross-origin partial response requirements for CORS presence.

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 33 matching lines @@
  private:
   DISALLOW_COPY_AND_ASSIGN(MockBufferedDataSourceHost);
 };
 
 // Overrides CreateResourceLoader() to permit injecting a MockWebURLLoader.
 // Also keeps track of whether said MockWebURLLoader is actively loading.
 class MockBufferedDataSource : public BufferedDataSource {
  public:
   MockBufferedDataSource(
       const GURL& url,
+      BufferedResourceLoader::CORSMode cors_mode,
       const scoped_refptr<base::SingleThreadTaskRunner>& task_runner,
       WebLocalFrame* frame,
       BufferedDataSourceHost* host)
       : BufferedDataSource(url,
-                           BufferedResourceLoader::kUnspecified,
+                           cors_mode,
                            task_runner,
                            frame,
                            new media::MediaLog(),
                            host,
                            base::Bind(&MockBufferedDataSource::set_downloading,
                                       base::Unretained(this))),
         downloading_(false),
         loading_(false) {}
   virtual ~MockBufferedDataSource() {}
 
@@ skipping 52 matching lines @@
     view_->setMainFrame(frame_);
   }
 
   virtual ~BufferedDataSourceTest() {
     view_->close();
     frame_->close();
   }
 
   MOCK_METHOD1(OnInitialize, void(bool));
 
-  void Initialize(const char* url, bool expected) {
+  void InitializeWithCORS(const char* url,
+                          bool expected,
+                          BufferedResourceLoader::CORSMode cors_mode) {
     GURL gurl(url);
-    data_source_.reset(
-        new MockBufferedDataSource(gurl,
-                                   message_loop_.task_runner(),
-                                   view_->mainFrame()->toWebLocalFrame(),
-                                   &host_));
+    data_source_.reset(new MockBufferedDataSource(
+        gurl, cors_mode, message_loop_.task_runner(),
+        view_->mainFrame()->toWebLocalFrame(), &host_));
     data_source_->SetPreload(preload_);
 
     response_generator_.reset(new TestResponseGenerator(gurl, kFileSize));
     ExpectCreateResourceLoader();
     EXPECT_CALL(*this, OnInitialize(expected));
     data_source_->Initialize(base::Bind(&BufferedDataSourceTest::OnInitialize,
                                         base::Unretained(this)));
     message_loop_.RunUntilIdle();
 
     bool is_http = gurl.SchemeIsHTTPOrHTTPS();
     EXPECT_EQ(data_source_->downloading(), is_http);
   }
 
+  void Initialize(const char* url, bool expected) {
+    InitializeWithCORS(url, expected, BufferedResourceLoader::kUnspecified);
+  }
+
   // 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());
   }
 
   // Helper to initialize tests with a valid 206 response.
   void InitializeWith206Response() {
@@ skipping 409 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(BufferedDataSourceTest,
+       Http_MixedResponse_ServiceWorkerProxiedAndDifferentOriginResponseCORS) {
+  InitializeWithCORS(kHttpUrl, true, BufferedResourceLoader::kAnonymous);
+  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(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