Migrate DataSourceFactory to new callback system.

BUG=90214
TEST=BufferedDataSourceTest.*, SimpleDataSourceTest.*

Review URL: http://codereview.chromium.org/7461035

git-svn-id: svn://svn.chromium.org/chrome/trunk/src@93723 0039d316-1c4b-4281-b951-d872f2087c98

5 files changed, 94 insertions, 322 deletions

diff --git a/media/base/async_filter_factory_base.cc b/media/base/async_filter_factory_base.cc
deleted file mode 100644
index c8bb307..0000000
--- a/media/base/async_filter_factory_base.cc
+++ /dev/null
@@ -1,112 +0,0 @@
-// Copyright (c) 2011 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 "media/base/async_filter_factory_base.h"
-
-#include "base/logging.h"
-#include "base/stl_util.h"
-
-namespace media {
-
-AsyncDataSourceFactoryBase::AsyncDataSourceFactoryBase() {}
-
-AsyncDataSourceFactoryBase::~AsyncDataSourceFactoryBase() {
-  base::AutoLock auto_lock(lock_);
-  STLDeleteElements(&outstanding_requests_);
-}
-
-void AsyncDataSourceFactoryBase::Build(const std::string& url,
-                                       BuildCallback* callback) {
-  DCHECK(callback);
-  BuildRequest* request = NULL;
-  {
-    base::AutoLock auto_lock(lock_);
-
-    if (url.empty()) {
-      RunAndDestroyCallback(PIPELINE_ERROR_URL_NOT_FOUND, callback);
-      return;
-    }
-
-    if (!AllowRequests()) {
-      RunAndDestroyCallback(DATASOURCE_ERROR_URL_NOT_SUPPORTED, callback);
-      return;
-    }
-
-    request = CreateRequest(url, callback);
-
-    if (!request) {
-      RunAndDestroyCallback(DATASOURCE_ERROR_URL_NOT_SUPPORTED, callback);
-      return;
-    }
-
-    outstanding_requests_.insert(request);
-  }
-
-  request->Start(NewCallback(this,
-                             &AsyncDataSourceFactoryBase::BuildRequestDone));
-}
-
-void AsyncDataSourceFactoryBase::RunAndDestroyCallback(
-    PipelineStatus error,
-    BuildCallback* callback) const {
-  DCHECK_NE(error, PIPELINE_OK);
-  DCHECK(callback);
-
-  callback->Run(error, static_cast<DataSource*>(NULL));
-  delete callback;
-}
-
-void AsyncDataSourceFactoryBase::BuildRequestDone(BuildRequest* request) {
-  base::AutoLock auto_lock(lock_);
-  outstanding_requests_.erase(request);
-  delete request;
-}
-
-AsyncDataSourceFactoryBase::BuildRequest::BuildRequest(const std::string& url,
-                                                       BuildCallback* callback)
-    : url_(url),
-      callback_(callback) {
-}
-
-AsyncDataSourceFactoryBase::BuildRequest::~BuildRequest() {}
-
-void AsyncDataSourceFactoryBase::BuildRequest::Start(
-    RequestDoneCallback* done_callback) {
-  DCHECK(done_callback);
-  DCHECK(!done_callback_.get());
-
-  done_callback_.reset(done_callback);
-  DoStart();
-  // Don't do anything after this line since the object could
-  // have been deleted at this point if the request was completed
-  // inside the call.
-}
-
-void AsyncDataSourceFactoryBase::BuildRequest::RequestComplete(
-    PipelineStatus status,
-    DataSource* data_source) {
-  DCHECK(callback_.get());
-  DCHECK(done_callback_.get());
-
-  // Transfer ownership to local variables just in case the
-  // request object gets deleted by one of the callbacks.
-  scoped_ptr<RequestDoneCallback> done_callback(done_callback_.release());
-  scoped_ptr<BuildCallback> callback(callback_.release());
-
-  // Notify factory that this request has completed. We do this before
-  // calling |callback| so the factory doesn't consider this request
-  // pending if |callback| happens to destroy the factory.
-  //
-  // NOTE: This BuildRequest object is destroyed inside this callback so
-  //       no modifications should be made to this object after this call.
-  done_callback->Run(this);
-
-  callback->Run(status, data_source);
-}
-
-const std::string& AsyncDataSourceFactoryBase::BuildRequest::url() const {
-  return url_;
-}
-
-}  // namespace media
diff --git a/media/base/async_filter_factory_base.h b/media/base/async_filter_factory_base.h
deleted file mode 100644
index 34ff831..0000000
--- a/media/base/async_filter_factory_base.h
+++ /dev/null
@@ -1,129 +0,0 @@
-// Copyright (c) 2011 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 MEDIA_BASE_ASYNC_FILTER_FACTORY_BASE_H_
-#define MEDIA_BASE_ASYNC_FILTER_FACTORY_BASE_H_
-
-#include <set>
-
-#include "base/memory/scoped_ptr.h"
-#include "base/synchronization/lock.h"
-#include "media/base/filter_factories.h"
-
-namespace media {
-
-// This is a helper base class for DataSourceFactory implementation that
-// actually require asynchronous operations to build a data source. It
-// provides a common framework for dealing with an asychronous build.
-// Factories are expected to derive from this object and implement
-// AllowRequests(), CreateRequest(), and an custom implementation that derives
-// from BuildRequest.
-//
-// AllowRequests() just checks to see if the factory is in a state where it can
-// accept Build() requests. If it returns false, this base class will signal an
-// error through the BuildCallback and not call any of the other code. If
-// AllowRequests() returns true then this class will continue with the build
-// process by calling CreateRequest().
-//
-// CreateRequest() allows the derived implementation to create an instance of
-// their custom BuildRequest implementation that is specific to its asynchronous
-// build process. The custom BuildRequest should contain all of the state that
-// needs to be maintained for a particular build request. This state could
-// consist of partially initialized objects that require asynchronous operations
-// to complete before the build completes. This implementation MUST derive from
-// AsyncDataSourceFactoryBase::BuildRequest.
-//
-// Once CreateRequest() returns a BuildRequest implementation, this class adds
-// the object to its request list and then calls Start() on the BuildRequest
-// instance. BuildRequest::Start() manages storing the |done_callback| passed to
-// it and then call DoStart() on the derived object. DoStart() is where this
-// framework expects any neccesary asynchronous operations to be initiated.
-//
-// Once all asynchronous operations are completed and a fully initialized
-// DataSource object has been created, the BuildRequest instance should call
-// the RequestComplete() method. This call signals the end of the request and
-// the BuildRequest should be in a state where it can be deleted from inside
-// this call. If an error occurs during the build process, RequestComplete()
-// can also be called to signal the error.
-class AsyncDataSourceFactoryBase : public DataSourceFactory {
- public:
-  AsyncDataSourceFactoryBase();
-  virtual ~AsyncDataSourceFactoryBase();
-
-  // DataSourceFactory method.
-  // Derived classes should not overload this Build() method. AllowRequests() &
-  // CreateRequest() should be implemented instead.
-  virtual void Build(const std::string& url, BuildCallback* callback);
-
-  // DataSourceFactory method.
-  // Clone() must be implemented by derived classes.
-  // NOTE: Nothing in this base class needs to be cloned because this class
-  // only keeps track of pending requests, which are not part of the cloning
-  // process.
-  virtual DataSourceFactory* Clone() const = 0;
-
- protected:
-  class BuildRequest {
-   public:
-    BuildRequest(const std::string& url, BuildCallback* callback);
-    virtual ~BuildRequest();
-
-    typedef Callback1<BuildRequest*>::Type RequestDoneCallback;
-    // Starts the build request.
-    void Start(RequestDoneCallback* done_callback);
-
-    // Derived objects call this method to indicate that the build request
-    // has completed. If the build was successful |status| should be set to
-    // PIPELINE_OK and |data_source| should contain the DataSource object
-    // that was built by this request. Ownership of |data_source| is being
-    // passed in this call. If an error occurs during the build process, this
-    // method should be called with |status| set to an appropriate status code
-    // and |data_source| set to NULL.
-    //
-    // The derived object should be in a state where it can be deleted from
-    // within this call. This class as well AsyncDataSourceFactoryBase use this
-    // method to cleanup state associated with this request.
-    void RequestComplete(media::PipelineStatus status, DataSource* data_source);
-
-   protected:
-    // Implemented by the derived object to start the build. Called by Start().
-    virtual void DoStart() = 0;
-
-    // Gets the requested URL.
-    const std::string& url() const;
-
-   private:
-    std::string url_;
-    scoped_ptr<BuildCallback> callback_;
-    scoped_ptr<RequestDoneCallback> done_callback_;
-
-    DISALLOW_COPY_AND_ASSIGN(BuildRequest);
-  };
-
-  // Implemented by derived class. Called by Build() to check if the
-  // factory is in a state where it can accept requests.
-  virtual bool AllowRequests() const = 0;
-
-  // Implemented by derived class. Called by Build() to allow derived objects
-  // to create their own custom BuildRequest implementations.
-  virtual BuildRequest* CreateRequest(const std::string& url,
-                                      BuildCallback* callback) = 0;
-
- private:
-  void RunAndDestroyCallback(PipelineStatus status,
-                             BuildCallback* callback) const;
-
-  typedef Callback1<BuildRequest*>::Type RequestDoneCallback;
-  void BuildRequestDone(BuildRequest* request);
-
-  base::Lock lock_;
-  typedef std::set<BuildRequest*> RequestSet;
-  RequestSet outstanding_requests_;
-
-  DISALLOW_COPY_AND_ASSIGN(AsyncDataSourceFactoryBase);
-};
-
-}  // namespace media
-
-#endif  // MEDIA_BASE_ASYNC_FILTER_FACTORY_BASE_H_
diff --git a/media/base/composite_data_source_factory.cc b/media/base/composite_data_source_factory.cc
index 9703c85..2ec4435 100644
--- a/media/base/composite_data_source_factory.cc
+++ b/media/base/composite_data_source_factory.cc
@@ -4,6 +4,7 @@
 
 #include "media/base/composite_data_source_factory.h"
 
+#include "base/bind.h"
 #include "base/callback.h"
 #include "base/logging.h"
 #include "base/memory/scoped_ptr.h"
@@ -11,23 +12,74 @@
 
 namespace media {
 
-class CompositeDataSourceFactory::BuildRequest
-    : public AsyncDataSourceFactoryBase::BuildRequest {
- public:
-  BuildRequest(const std::string& url, BuildCallback* callback,
-               const FactoryList& factories);
-  ~BuildRequest();
+typedef std::list<DataSourceFactory*> FactoryList;
+
+static void CallNextFactory(FactoryList* factories,
+                            const std::string& url,
+                            const DataSourceFactory::BuildCB& callback);
+
+// Called when the first factory in |factories| completes a Build() request.
+// |factories| - The list of factories to try. Ownership is being
+//               passed to this function here.
+// |url| - The URL from the originating Build() call.
+// |callback| - The callback from the originating Build() call.
+// |status| - The status returned from the factory.
+// |data_source| - The DataSource built by the factory. NULL if
+//                 |status| is not PIPELINE_OK. Ownership is passed here.
+static void OnBuildDone(FactoryList* factories,
+                        const std::string& url,
+                        const DataSourceFactory::BuildCB& callback,
+                        PipelineStatus status,
+                        DataSource* data_source) {
+  DCHECK(factories);
+  DCHECK(!factories->empty());
+
+  // Remove & destroy front factory since we are done using it now.
+  delete factories->front();
+  factories->pop_front();
 
- protected:
-  // AsyncDataSourceFactoryBase::BuildRequest method.
-  virtual void DoStart();
+  if (status == PIPELINE_OK) {
+    DCHECK(data_source);
+    callback.Run(status, data_source);
+
+    // Delete the factory list and all remaining factories.
+    STLDeleteElements(factories);
+    delete factories;
+    return;
+  }
+
+  // Try the next factory if |status| indicates the factory didn't know how to
+  // build a DataSource for |url|.
+  DCHECK(!data_source);
+  if ((status == DATASOURCE_ERROR_URL_NOT_SUPPORTED) &&
+      !factories->empty()) {
+    CallNextFactory(factories, url, callback);
+    return;
+  }
 
- private:
-  void CallNextFactory();
-  void OnBuildDone(PipelineStatus status, DataSource* data_source);
+  // No more factories to try or a factory that could handle the
+  // request encountered an error.
+  callback.Run(status, NULL);
 
-  FactoryList factories_;
-};
+  // Delete the factory list and all remaining factories.
+  STLDeleteElements(factories);
+  delete factories;
+}
+
+// Calls Build() on the front factory in |factories|.
+// Ownership of |factories| is passed to this method.
+static void CallNextFactory(FactoryList* factories,
+                            const std::string& url,
+                            const DataSourceFactory::BuildCB& callback) {
+  DCHECK(factories);
+  DCHECK(!factories->empty());
+
+  DataSourceFactory* factory = factories->front();
+  factory->Build(url, base::Bind(&OnBuildDone,
+                                 factories,
+                                 url,
+                                 callback));
+}
 
 CompositeDataSourceFactory::CompositeDataSourceFactory() {}
 
@@ -40,69 +92,35 @@ void CompositeDataSourceFactory::AddFactory(DataSourceFactory* factory) {
   factories_.push_back(factory);
 }
 
-DataSourceFactory* CompositeDataSourceFactory::Clone() const {
-  CompositeDataSourceFactory* new_factory = new CompositeDataSourceFactory();
+void CompositeDataSourceFactory::Build(const std::string& url,
+                                       const BuildCB& callback) {
+  if (factories_.empty()) {
+    callback.Run(DATASOURCE_ERROR_URL_NOT_SUPPORTED, NULL);
+    return;
+  }
 
+  // Construct the list of factories to try.
+  scoped_ptr<FactoryList> factories(new FactoryList());
   for (FactoryList::const_iterator itr = factories_.begin();
        itr != factories_.end();
        ++itr) {
-    new_factory->AddFactory((*itr)->Clone());
+    factories->push_back((*itr)->Clone());
   }
 
-  return new_factory;
+  // Start trying to build a DataSource from the factories in the list.
+  CallNextFactory(factories.release(), url, callback);
 }
 
-bool CompositeDataSourceFactory::AllowRequests() const {
-  return !factories_.empty();
-}
-
-AsyncDataSourceFactoryBase::BuildRequest*
-CompositeDataSourceFactory::CreateRequest(const std::string& url,
-                                          BuildCallback* callback) {
-  return new BuildRequest(url, callback, factories_);
-}
-
-CompositeDataSourceFactory::BuildRequest::BuildRequest(
-    const std::string& url,
-    BuildCallback* callback,
-    const FactoryList& factories)
-    : AsyncDataSourceFactoryBase::BuildRequest(url, callback),
-      factories_(factories){
-  DCHECK(!factories.empty());
-}
-
-CompositeDataSourceFactory::BuildRequest::~BuildRequest() {}
-
-void CompositeDataSourceFactory::BuildRequest::DoStart() {
-  CallNextFactory();
-}
-
-void CompositeDataSourceFactory::BuildRequest::CallNextFactory() {
-  DCHECK(!factories_.empty());
-
-  DataSourceFactory* factory = factories_.front();
-  factories_.pop_front();
-
-  factory->Build(url(), NewCallback(this, &BuildRequest::OnBuildDone));
-}
-
-void CompositeDataSourceFactory::BuildRequest::OnBuildDone(
-    PipelineStatus status,
-    DataSource* data_source) {
-
-  if (status == PIPELINE_OK) {
-    DCHECK(data_source);
-    RequestComplete(status, data_source);
-    return;
-  }
+DataSourceFactory* CompositeDataSourceFactory::Clone() const {
+  CompositeDataSourceFactory* new_factory = new CompositeDataSourceFactory();
 
-  DCHECK(!data_source);
-  if ((status == DATASOURCE_ERROR_URL_NOT_SUPPORTED) && !factories_.empty()) {
-    CallNextFactory();
-    return;
+  for (FactoryList::const_iterator itr = factories_.begin();
+       itr != factories_.end();
+       ++itr) {
+    new_factory->AddFactory((*itr)->Clone());
   }
 
-  RequestComplete(status, data_source);
+  return new_factory;
 }
 
 }  // namespace media
diff --git a/media/base/composite_data_source_factory.h b/media/base/composite_data_source_factory.h
index 799960d..53b2dfc 100644
--- a/media/base/composite_data_source_factory.h
+++ b/media/base/composite_data_source_factory.h
@@ -8,12 +8,13 @@
 #include <list>
 #include <set>
 
+#include "base/compiler_specific.h"
 #include "base/synchronization/lock.h"
-#include "media/base/async_filter_factory_base.h"
+#include "media/base/filter_factories.h"
 
 namespace media {
 
-class CompositeDataSourceFactory : public AsyncDataSourceFactoryBase {
+class CompositeDataSourceFactory : public DataSourceFactory {
  public:
   CompositeDataSourceFactory();
   virtual ~CompositeDataSourceFactory();
@@ -21,18 +22,11 @@ class CompositeDataSourceFactory : public AsyncDataSourceFactoryBase {
   // Add factory to this composite. Ownership is transferred here.
   void AddFactory(DataSourceFactory* factory);
 
-  // DataSourceFactory method.
-  virtual DataSourceFactory* Clone() const;
-
- protected:
-  // AsyncDataSourceFactoryBase methods.
-  virtual bool AllowRequests() const;
-  virtual AsyncDataSourceFactoryBase::BuildRequest* CreateRequest(
-      const std::string& url, BuildCallback* callback);
+  // DataSourceFactory methods.
+  virtual void Build(const std::string& url, const BuildCB& callback) OVERRIDE;
+  virtual DataSourceFactory* Clone() const OVERRIDE;
 
  private:
-  class BuildRequest;
-
   typedef std::list<DataSourceFactory*> FactoryList;
   FactoryList factories_;
 
diff --git a/media/base/filter_factories.h b/media/base/filter_factories.h
index 5286b3f..b7f2a69 100644
--- a/media/base/filter_factories.h
+++ b/media/base/filter_factories.h
@@ -5,8 +5,9 @@
 #ifndef MEDIA_BASE_FILTER_FACTORIES_H_
 #define MEDIA_BASE_FILTER_FACTORIES_H_
 
-#include<string>
+#include <string>
 
+#include "base/callback.h"
 #include "base/callback_old.h"
 #include "media/base/pipeline_status.h"
 
@@ -18,12 +19,12 @@ class DataSource;
 class DataSourceFactory {
  public:
   // Ownership of the DataSource is transferred through this callback.
-  typedef Callback2<PipelineStatus, DataSource*>::Type BuildCallback;
+  typedef base::Callback<void(PipelineStatus, DataSource*)> BuildCB;
 
   virtual ~DataSourceFactory();
 
   // Builds a DataSource for |url| and returns it via |callback|.
-  virtual void Build(const std::string& url, BuildCallback* callback) = 0;
+  virtual void Build(const std::string& url, const BuildCB& callback) = 0;
 
   // Makes a copy of this factory.
   // NOTE: Pending requests are not cloned.