Remove use of PipelineStatus from BufferedDataSource and FileDataSource.

webkit/media/buffered_data_source.h

 // 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.
 
 #ifndef WEBKIT_MEDIA_BUFFERED_DATA_SOURCE_H_
 #define WEBKIT_MEDIA_BUFFERED_DATA_SOURCE_H_
 
 #include <string>
 
 #include "base/callback.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/synchronization/lock.h"
 #include "googleurl/src/gurl.h"
 #include "media/base/data_source.h"
-#include "media/base/pipeline_status.h"
 #include "webkit/media/buffered_resource_loader.h"
 #include "webkit/media/preload.h"
 
 class MessageLoop;
 
 namespace media {
 class MediaLog;
 }
 
 namespace webkit_media {
 
 // A data source capable of loading URLs and buffering the data using an
 // in-memory sliding window.
 //
 // BufferedDataSource must be created and initialized on the render thread
 // before being passed to other threads. It may be deleted on any thread.
 class BufferedDataSource : public media::DataSource {
  public:
   typedef base::Callback<void(bool)> DownloadingCB;
 
   // |downloading_cb| will be called whenever the downloading/paused state of
   // the source changes.
   BufferedDataSource(MessageLoop* render_loop,
                      WebKit::WebFrame* frame,
                      media::MediaLog* media_log,
                      const DownloadingCB& downloading_cb);
 
-  // Initialize this object using |url| and |cors_mode|, and call |status_cb|
-  // when initialization has completed.
+  // Initialize this object using |url| and |cors_mode|, executing |init_cb|
+  // with the result of initialization when it has completed.
   //
   // Method called on the render thread.
+  typedef base::Callback<void(bool)> InitializeCB;
   void Initialize(
       const GURL& url,
       BufferedResourceLoader::CORSMode cors_mode,
-      const media::PipelineStatusCB& status_cb);
+      const InitializeCB& init_cb);
 
   // Adjusts the buffering algorithm based on the given preload value.
   void SetPreload(Preload preload);
 
   // Returns true if the media resource has a single origin, false otherwise.
   // Only valid to call after Initialize() has completed.
   //
   // Method called on the render thread.
   bool HasSingleOrigin();
 
@@ skipping 49 matching lines @@
 
   // The method that performs actual read. This method can only be executed on
   // the render thread.
   void ReadInternal();
 
   // Calls |read_cb_| and reset all read parameters. Non-negative |bytes_read|
   // values represent successful reads, otherwise |bytes_read| should be
   // kReadError.
   void DoneRead_Locked(int bytes_read);
 
-  // Calls |initialize_cb_| and reset it.
-  void DoneInitialization_Locked(media::PipelineStatus status);
-
   // BufferedResourceLoader::Start() callback for initial load.
   void StartCallback(BufferedResourceLoader::Status status);
 
   // BufferedResourceLoader::Start() callback for subsequent loads (i.e.,
   // when accessing ranges that are outside initial buffered region).
   void PartialReadStartCallback(BufferedResourceLoader::Status status);
 
   // BufferedResourceLoader callbacks.
   void ReadCallback(BufferedResourceLoader::Status status, int bytes_read);
   void LoadingStateChangedCallback(BufferedResourceLoader::LoadingState state);
@@ skipping 19 matching lines @@
   // i.e. range request is not supported.
   bool streaming_;
 
   // A webframe for loading.
   WebKit::WebFrame* frame_;
 
   // A resource loader for the media resource.
   scoped_ptr<BufferedResourceLoader> loader_;
 
   // Callback method from the pipeline for initialization.
-  media::PipelineStatusCB initialize_cb_;
+  InitializeCB init_cb_;
 
   // Read parameters received from the Read() method call.
   media::DataSource::ReadCB read_cb_;
   int read_size_;
   uint8* read_buffer_;
   // Retained between reads to make sense of buffering information.
   int64 last_read_start_;
 
   // This buffer is intermediate, we use it for BufferedResourceLoader to write
   // to. And when read in BufferedResourceLoader is done, we copy data from
   // this buffer to |read_buffer_|. The reason for an additional copy is that
   // we don't own |read_buffer_|. But since the read operation is asynchronous,
   // |read_buffer| can be destroyed at any time, so we only copy into
   // |read_buffer| in the final step when it is safe.
   // Memory is allocated for this member during initialization of this object
   // because we want buffer to be passed into BufferedResourceLoader to be
   // always non-null. And by initializing this member with a default size we can
   // avoid creating zero-sized buffered if the first read has zero size.
   scoped_array<uint8> intermediate_read_buffer_;
   int intermediate_read_buffer_size_;
 
   // The message loop of the render thread.
   MessageLoop* render_loop_;
 
   // Protects |stop_signal_received_|, |stopped_on_render_loop_| and
-  // |initialize_cb_|.
+  // |init_cb_|.
   base::Lock lock_;
 
   // Stop signal to suppressing activities. This variable is set on the pipeline
   // thread and read from the render thread.
   bool stop_signal_received_;
 
   // This variable is set by CleanupTask() that indicates this object is stopped
   // on the render thread and work should no longer progress.
   bool stopped_on_render_loop_;
 
@@ skipping 17 matching lines @@
   scoped_refptr<media::MediaLog> media_log_;
 
   DownloadingCB downloading_cb_;
 
   DISALLOW_COPY_AND_ASSIGN(BufferedDataSource);
 };
 
 }  // namespace webkit_media
 
 #endif  // WEBKIT_MEDIA_BUFFERED_DATA_SOURCE_H_