Remove use of PipelineStatus from BufferedDataSource and FileDataSource.

webkit/media/buffered_data_source_unittest.cc

 // Copyright (c) 2012 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.h"
 #include "media/base/media_log.h"
 #include "media/base/mock_callback.h"
 #include "media/base/mock_data_source_host.h"
 #include "media/base/mock_filters.h"
@@ skipping 86 matching lines @@
 
     data_source_ = new MockBufferedDataSource(&message_loop_,
                                               view_->mainFrame());
     data_source_->set_host(&host_);
   }
 
   virtual ~BufferedDataSourceTest() {
     view_->close();
   }
 
-  void Initialize(const char* url, media::PipelineStatus expected) {
+  MOCK_METHOD1(OnInitialize, void(bool));
+
+  void Initialize(const char* url, bool expected) {
     GURL gurl(url);
     response_generator_.reset(new TestResponseGenerator(gurl, kFileSize));
 
     ExpectCreateResourceLoader();
-    data_source_->Initialize(gurl,
-                             BufferedResourceLoader::kUnspecified,
-                             media::NewExpectedStatusCB(expected));
+    EXPECT_CALL(*this, OnInitialize(expected));
+    data_source_->Initialize(
+        gurl, BufferedResourceLoader::kUnspecified, base::Bind(
+            &BufferedDataSourceTest::OnInitialize, base::Unretained(this)));
     message_loop_.RunAllPending();
 
     bool is_http = gurl.SchemeIs(kHttpScheme) || gurl.SchemeIs(kHttpsScheme);
     EXPECT_EQ(data_source_->downloading(), is_http);
   }
 
   // Helper to initialize tests with a valid 206 response.
   void InitializeWith206Response() {
-    Initialize(kHttpUrl, media::PIPELINE_OK);
+    Initialize(kHttpUrl, true);
 
     EXPECT_CALL(host_, SetTotalBytes(response_generator_->content_length()));
     Respond(response_generator_->Generate206(0));
   }
 
   // Helper to initialize tests with a valid file:// response.
   void InitializeWithFileResponse() {
-    Initialize(kFileUrl, media::PIPELINE_OK);
+    Initialize(kFileUrl, true);
 
     EXPECT_CALL(host_, SetTotalBytes(kFileSize));
     EXPECT_CALL(host_, AddBufferedByteRange(0, kFileSize));
     Respond(response_generator_->GenerateFileResponse(0));
   }
 
   // Stops any active loaders and shuts down the data source.
   //
   // This typically happens when the page is closed and for our purposes is
   // appropriate to do when tearing down a test.
@@ skipping 69 matching lines @@
   MessageLoop message_loop_;
 
  private:
   // Used for calling BufferedDataSource::Read().
   uint8 buffer_[kDataSize];
 
   DISALLOW_COPY_AND_ASSIGN(BufferedDataSourceTest);
 };
 
 TEST_F(BufferedDataSourceTest, Range_Supported) {
-  Initialize(kHttpUrl, media::PIPELINE_OK);
+  Initialize(kHttpUrl, true);
 
   EXPECT_CALL(host_, SetTotalBytes(response_generator_->content_length()));
   Respond(response_generator_->Generate206(0));
 
   EXPECT_TRUE(data_source_->loading());
   EXPECT_FALSE(data_source_->IsStreaming());
   Stop();
 }
 
 TEST_F(BufferedDataSourceTest, Range_InstanceSizeUnknown) {
-  Initialize(kHttpUrl, media::PIPELINE_OK);
+  Initialize(kHttpUrl, true);
 
   Respond(response_generator_->Generate206(
       0, TestResponseGenerator::kNoContentRangeInstanceSize));
 
   EXPECT_TRUE(data_source_->loading());
   EXPECT_TRUE(data_source_->IsStreaming());
   Stop();
 }
 
 TEST_F(BufferedDataSourceTest, Range_NotFound) {
-  Initialize(kHttpUrl, media::PIPELINE_ERROR_NETWORK);
+  Initialize(kHttpUrl, false);
   Respond(response_generator_->Generate404());
 
   EXPECT_FALSE(data_source_->loading());
   Stop();
 }
 
 TEST_F(BufferedDataSourceTest, Range_NotSupported) {
-  Initialize(kHttpUrl, media::PIPELINE_OK);
+  Initialize(kHttpUrl, true);
   EXPECT_CALL(host_, SetTotalBytes(response_generator_->content_length()));
   Respond(response_generator_->Generate200());
 
   EXPECT_TRUE(data_source_->loading());
   EXPECT_TRUE(data_source_->IsStreaming());
   Stop();
 }
 
 // Special carve-out for Apache versions that choose to return a 200 for
 // Range:0- ("because it's more efficient" than a 206)
 TEST_F(BufferedDataSourceTest, Range_SupportedButReturned200) {
-  Initialize(kHttpUrl, media::PIPELINE_OK);
+  Initialize(kHttpUrl, true);
   EXPECT_CALL(host_, SetTotalBytes(response_generator_->content_length()));
   WebURLResponse response = response_generator_->Generate200();
   response.setHTTPHeaderField(WebString::fromUTF8("Accept-Ranges"),
                               WebString::fromUTF8("bytes"));
   Respond(response);
 
   EXPECT_TRUE(data_source_->loading());
   EXPECT_FALSE(data_source_->IsStreaming());
   Stop();
 }
 
 TEST_F(BufferedDataSourceTest, Range_MissingContentRange) {
-  Initialize(kHttpUrl, media::PIPELINE_ERROR_NETWORK);
+  Initialize(kHttpUrl, false);
   Respond(response_generator_->Generate206(
       0, TestResponseGenerator::kNoContentRange));
 
   EXPECT_FALSE(data_source_->loading());
   Stop();
 }
 
 TEST_F(BufferedDataSourceTest, Range_MissingContentLength) {
-  Initialize(kHttpUrl, media::PIPELINE_OK);
+  Initialize(kHttpUrl, true);
 
   // It'll manage without a Content-Length response.
   EXPECT_CALL(host_, SetTotalBytes(response_generator_->content_length()));
   Respond(response_generator_->Generate206(
       0, TestResponseGenerator::kNoContentLength));
 
   EXPECT_TRUE(data_source_->loading());
   EXPECT_FALSE(data_source_->IsStreaming());
   Stop();
 }
 
 TEST_F(BufferedDataSourceTest, Range_WrongContentRange) {
-  Initialize(kHttpUrl, media::PIPELINE_ERROR_NETWORK);
+  Initialize(kHttpUrl, false);
 
   // Now it's done and will fail.
   Respond(response_generator_->Generate206(1337));
 
   EXPECT_FALSE(data_source_->loading());
   Stop();
 }
 
 // Test the case where the initial response from the server indicates that
 // Range requests are supported, but a later request prove otherwise.
@@ skipping 136 matching lines @@
 
   // It'll error after this.
   EXPECT_CALL(*this, ReadCallback(media::DataSource::kReadError));
   FinishLoading();
 
   EXPECT_FALSE(data_source_->loading());
   Stop();
 }
 
 TEST_F(BufferedDataSourceTest, File_InstanceSizeUnknown) {
-  Initialize(kFileUrl, media::PIPELINE_ERROR_NETWORK);
+  Initialize(kFileUrl, false);
   EXPECT_FALSE(data_source_->downloading());
 
   Respond(response_generator_->GenerateFileResponse(-1));
 
   EXPECT_FALSE(data_source_->loading());
   Stop();
 }
 
 TEST_F(BufferedDataSourceTest, File_Successful) {
   InitializeWithFileResponse();
@@ skipping 116 matching lines @@
   ReceiveData(kDataSize / 2);
 
   // Receive last half of the read but no buffering update.
   EXPECT_CALL(*this, ReadCallback(kDataSize));
   ReceiveData(kDataSize / 2);
 
   Stop();
 }
 
 }  // namespace webkit_media