Changing constructor of BufferedDataSource to accept GURL and CORSMode

content/renderer/media/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 "content/public/common/url_constants.h"
 #include "content/renderer/media/buffered_data_source.h"
 #include "content/renderer/media/test_response_generator.h"
 #include "content/test/mock_webframeclient.h"
@@ skipping 30 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,
       const scoped_refptr<base::MessageLoopProxy>& message_loop,
       WebLocalFrame* frame,
       BufferedDataSourceHost* host)
-      : BufferedDataSource(message_loop, frame, new media::MediaLog(), host,
+      : BufferedDataSource(url,
+                           BufferedResourceLoader::kUnspecified,
+                           message_loop,
+                           frame,
+                           new media::MediaLog(),
+                           host,
                            base::Bind(&MockBufferedDataSource::set_downloading,
                                       base::Unretained(this))),
         downloading_(false),
-        loading_(false) {
-  }
+        loading_(false) {}
   virtual ~MockBufferedDataSource() {}
 
   MOCK_METHOD2(CreateResourceLoader, BufferedResourceLoader*(int64, int64));
   BufferedResourceLoader* CreateMockResourceLoader(int64 first_byte_position,
                                                    int64 last_byte_position) {
     CHECK(!loading_) << "Previous resource load wasn't cancelled";
 
     BufferedResourceLoader* loader =
         BufferedDataSource::CreateResourceLoader(first_byte_position,
                                                  last_byte_position);
@@ skipping 30 matching lines @@
 static const int kDataSize = 1024;
 
 static const char kHttpUrl[] = "http://localhost/foo.webm";
 static const char kFileUrl[] = "file:///tmp/bar.webm";
 
 class BufferedDataSourceTest : public testing::Test {
  public:
   BufferedDataSourceTest()
       : view_(WebView::create(NULL)), frame_(WebLocalFrame::create(&client_)) {
     view_->setMainFrame(frame_);
-
-    data_source_.reset(
-        new MockBufferedDataSource(message_loop_.message_loop_proxy(),
-                                   view_->mainFrame()->toWebLocalFrame(),
-                                   &host_));
   }
 
   virtual ~BufferedDataSourceTest() {
     view_->close();
     frame_->close();
   }
 
   MOCK_METHOD1(OnInitialize, void(bool));
 
   void Initialize(const char* url, bool expected) {
     GURL gurl(url);
+    data_source_.reset(
+        new MockBufferedDataSource(gurl,
+                                   message_loop_.message_loop_proxy(),
+                                   view_->mainFrame()->toWebLocalFrame(),
+                                   &host_));
+
     response_generator_.reset(new TestResponseGenerator(gurl, kFileSize));
-
     ExpectCreateResourceLoader();
     EXPECT_CALL(*this, OnInitialize(expected));
-    data_source_->Initialize(
-        gurl, BufferedResourceLoader::kUnspecified, base::Bind(
-            &BufferedDataSourceTest::OnInitialize, base::Unretained(this)));
+    data_source_->Initialize(base::Bind(&BufferedDataSourceTest::OnInitialize,
+                                        base::Unretained(this)));
     message_loop_.RunUntilIdle();
 
-    bool is_http =
-        gurl.SchemeIs(url::kHttpScheme) || gurl.SchemeIs(url::kHttpsScheme);
+    bool is_http = gurl.SchemeIsHTTPOrHTTPS();
     EXPECT_EQ(data_source_->downloading(), is_http);
   }
 
   // Helper to initialize tests with a valid 206 response.
   void InitializeWith206Response() {
     Initialize(kHttpUrl, true);
 
     EXPECT_CALL(host_, SetTotalBytes(response_generator_->content_length()));
     Respond(response_generator_->Generate206(0));
   }
@@ skipping 516 matching lines @@
   InitializeWithFileResponse();
 
   EXPECT_FALSE(data_source_->downloading());
   FinishLoading();
   EXPECT_FALSE(data_source_->downloading());
 
   Stop();
 }
 
 }  // namespace content