Revert 93723 - Migrate DataSourceFactory to new callback system.

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

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

TBR=acolwell@chromium.org
Review URL: http://codereview.chromium.org/7482029

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

9 files changed, 371 insertions, 122 deletions

diff --git a/media/base/async_filter_factory_base.cc b/media/base/async_filter_factory_base.cc
new file mode 100644
index 0000000..c8bb307
--- /dev/null
+++ b/media/base/async_filter_factory_base.cc
@@ -0,0 +1,112 @@
+// 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
new file mode 100644
index 0000000..34ff831
--- /dev/null
+++ b/media/base/async_filter_factory_base.h
@@ -0,0 +1,129 @@
+// 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 2ec4435..9703c85 100644
--- a/media/base/composite_data_source_factory.cc
+++ b/media/base/composite_data_source_factory.cc
@@ -4,7 +4,6 @@
 
 #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"
@@ -12,74 +11,23 @@
 
 namespace media {
 
-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();
+class CompositeDataSourceFactory::BuildRequest
+    : public AsyncDataSourceFactoryBase::BuildRequest {
+ public:
+  BuildRequest(const std::string& url, BuildCallback* callback,
+               const FactoryList& factories);
+  ~BuildRequest();
 
-  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;
-  }
+ protected:
+  // AsyncDataSourceFactoryBase::BuildRequest method.
+  virtual void DoStart();
 
-  // No more factories to try or a factory that could handle the
-  // request encountered an error.
-  callback.Run(status, NULL);
+ private:
+  void CallNextFactory();
+  void OnBuildDone(PipelineStatus status, DataSource* data_source);
 
-  // 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));
-}
+  FactoryList factories_;
+};
 
 CompositeDataSourceFactory::CompositeDataSourceFactory() {}
 
@@ -92,35 +40,69 @@ void CompositeDataSourceFactory::AddFactory(DataSourceFactory* factory) {
   factories_.push_back(factory);
 }
 
-void CompositeDataSourceFactory::Build(const std::string& url,
-                                       const BuildCB& callback) {
-  if (factories_.empty()) {
-    callback.Run(DATASOURCE_ERROR_URL_NOT_SUPPORTED, NULL);
-    return;
-  }
+DataSourceFactory* CompositeDataSourceFactory::Clone() const {
+  CompositeDataSourceFactory* new_factory = new CompositeDataSourceFactory();
 
-  // Construct the list of factories to try.
-  scoped_ptr<FactoryList> factories(new FactoryList());
   for (FactoryList::const_iterator itr = factories_.begin();
        itr != factories_.end();
        ++itr) {
-    factories->push_back((*itr)->Clone());
+    new_factory->AddFactory((*itr)->Clone());
   }
 
-  // Start trying to build a DataSource from the factories in the list.
-  CallNextFactory(factories.release(), url, callback);
+  return new_factory;
 }
 
-DataSourceFactory* CompositeDataSourceFactory::Clone() const {
-  CompositeDataSourceFactory* new_factory = new CompositeDataSourceFactory();
+bool CompositeDataSourceFactory::AllowRequests() const {
+  return !factories_.empty();
+}
 
-  for (FactoryList::const_iterator itr = factories_.begin();
-       itr != factories_.end();
-       ++itr) {
-    new_factory->AddFactory((*itr)->Clone());
+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;
   }
 
-  return new_factory;
+  DCHECK(!data_source);
+  if ((status == DATASOURCE_ERROR_URL_NOT_SUPPORTED) && !factories_.empty()) {
+    CallNextFactory();
+    return;
+  }
+
+  RequestComplete(status, data_source);
 }
 
 }  // namespace media
diff --git a/media/base/composite_data_source_factory.h b/media/base/composite_data_source_factory.h
index 53b2dfc..799960d 100644
--- a/media/base/composite_data_source_factory.h
+++ b/media/base/composite_data_source_factory.h
@@ -8,13 +8,12 @@
 #include <list>
 #include <set>
 
-#include "base/compiler_specific.h"
 #include "base/synchronization/lock.h"
-#include "media/base/filter_factories.h"
+#include "media/base/async_filter_factory_base.h"
 
 namespace media {
 
-class CompositeDataSourceFactory : public DataSourceFactory {
+class CompositeDataSourceFactory : public AsyncDataSourceFactoryBase {
  public:
   CompositeDataSourceFactory();
   virtual ~CompositeDataSourceFactory();
@@ -22,11 +21,18 @@ class CompositeDataSourceFactory : public DataSourceFactory {
   // Add factory to this composite. Ownership is transferred here.
   void AddFactory(DataSourceFactory* factory);
 
-  // DataSourceFactory methods.
-  virtual void Build(const std::string& url, const BuildCB& callback) OVERRIDE;
-  virtual DataSourceFactory* Clone() const OVERRIDE;
+  // DataSourceFactory method.
+  virtual DataSourceFactory* Clone() const;
+
+ protected:
+  // AsyncDataSourceFactoryBase methods.
+  virtual bool AllowRequests() const;
+  virtual AsyncDataSourceFactoryBase::BuildRequest* CreateRequest(
+      const std::string& url, BuildCallback* callback);
 
  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 b7f2a69..5286b3f 100644
--- a/media/base/filter_factories.h
+++ b/media/base/filter_factories.h
@@ -5,9 +5,8 @@
 #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"
 
@@ -19,12 +18,12 @@ class DataSource;
 class DataSourceFactory {
  public:
   // Ownership of the DataSource is transferred through this callback.
-  typedef base::Callback<void(PipelineStatus, DataSource*)> BuildCB;
+  typedef Callback2<PipelineStatus, DataSource*>::Type BuildCallback;
 
   virtual ~DataSourceFactory();
 
   // Builds a DataSource for |url| and returns it via |callback|.
-  virtual void Build(const std::string& url, const BuildCB& callback) = 0;
+  virtual void Build(const std::string& url, BuildCallback* callback) = 0;
 
   // Makes a copy of this factory.
   // NOTE: Pending requests are not cloned.
diff --git a/media/filters/ffmpeg_demuxer_factory.cc b/media/filters/ffmpeg_demuxer_factory.cc
index b42d09e..24e58dc 100644
--- a/media/filters/ffmpeg_demuxer_factory.cc
+++ b/media/filters/ffmpeg_demuxer_factory.cc
@@ -2,7 +2,6 @@
 // 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/filters/ffmpeg_demuxer.h"
 #include "media/filters/ffmpeg_demuxer_factory.h"
@@ -16,11 +15,11 @@ FFmpegDemuxerFactory::FFmpegDemuxerFactory(
 
 FFmpegDemuxerFactory::~FFmpegDemuxerFactory() {}
 
-// This class is a one-off whose raison d'etre is the lack of
+// This and the next class are one-offs whose raison d'etre is the lack of
 // currying functionality in base/callback_old.h's machinery.  Once media/
-// DemuxerFactory::BuildCallback is migrated to the new base/callback.h
-// machinery this should be removed and replaced with currying calls to
-// base::Bind().
+// PipelineStatusCallback and {DataSource,Demuxer}Factory::BuildCallback are
+// migrated to the new base/callback.h machinery these should be removed and
+// replaced with currying calls to base::Bind().
 class DemuxerCallbackAsPipelineStatusCallback : public PipelineStatusCallback {
  public:
   DemuxerCallbackAsPipelineStatusCallback(
@@ -43,25 +42,43 @@ class DemuxerCallbackAsPipelineStatusCallback : public PipelineStatusCallback {
   DISALLOW_IMPLICIT_CONSTRUCTORS(DemuxerCallbackAsPipelineStatusCallback);
 };
 
-static void DataSourceFactoryDone(DemuxerFactory::BuildCallback* callback,
-                                  MessageLoop* loop,
-                                  PipelineStatus status,
-                                  DataSource* data_source) {
-  scoped_ptr<DemuxerFactory::BuildCallback> cb(callback);
-  if (status != PIPELINE_OK) {
-    cb->Run(status, static_cast<Demuxer*>(NULL));
-    return;
+// See comments on DemuxerCallbackAsPipelineStatusCallback above.
+class DemuxerCallbackAsDataSourceCallback
+    : public DataSourceFactory::BuildCallback {
+ public:
+  DemuxerCallbackAsDataSourceCallback(DemuxerFactory::BuildCallback* cb,
+                                      MessageLoop* loop)
+      : cb_(cb), loop_(loop) {
+    DCHECK(cb_.get() && loop_);
   }
-  DCHECK(data_source);
-  scoped_refptr<FFmpegDemuxer> demuxer = new FFmpegDemuxer(loop);
-  demuxer->Initialize(
-      data_source,
-      new DemuxerCallbackAsPipelineStatusCallback(cb.release(), demuxer));
-}
+
+  virtual ~DemuxerCallbackAsDataSourceCallback() {}
+
+  virtual void RunWithParams(
+      const Tuple2<PipelineStatus, DataSource*>& params) {
+    PipelineStatus status = params.a;
+    DataSource* data_source = params.b;
+    if (status != PIPELINE_OK) {
+      cb_->Run(status, static_cast<Demuxer*>(NULL));
+      return;
+    }
+    DCHECK(data_source);
+    scoped_refptr<FFmpegDemuxer> demuxer = new FFmpegDemuxer(loop_);
+    demuxer->Initialize(
+        data_source,
+        new DemuxerCallbackAsPipelineStatusCallback(cb_.release(), demuxer));
+  }
+
+ private:
+  scoped_ptr<DemuxerFactory::BuildCallback> cb_;
+  MessageLoop* loop_;
+
+  DISALLOW_IMPLICIT_CONSTRUCTORS(DemuxerCallbackAsDataSourceCallback);
+};
 
 void FFmpegDemuxerFactory::Build(const std::string& url, BuildCallback* cb) {
-  data_source_factory_->Build(url,
-                              base::Bind(&DataSourceFactoryDone, cb, loop_));
+  data_source_factory_->Build(
+      url, new DemuxerCallbackAsDataSourceCallback(cb, loop_));
 }
 
 DemuxerFactory* FFmpegDemuxerFactory::Clone() const {
diff --git a/media/filters/file_data_source_factory.cc b/media/filters/file_data_source_factory.cc
index 91e1208..823fa01 100644
--- a/media/filters/file_data_source_factory.cc
+++ b/media/filters/file_data_source_factory.cc
@@ -14,11 +14,13 @@ FileDataSourceFactory::FileDataSourceFactory() {}
 FileDataSourceFactory::~FileDataSourceFactory() {}
 
 void FileDataSourceFactory::Build(const std::string& url,
-                                  const BuildCB& callback) {
-  DCHECK(!callback.is_null());
+                                  BuildCallback* callback) {
+  DCHECK(callback);
 
   if (url.empty()) {
-    callback.Run(media::PIPELINE_ERROR_URL_NOT_FOUND, NULL);
+    callback->Run(media::PIPELINE_ERROR_URL_NOT_FOUND,
+                  static_cast<media::DataSource*>(NULL));
+    delete callback;
     return;
   }
 
@@ -27,7 +29,8 @@ void FileDataSourceFactory::Build(const std::string& url,
   PipelineStatus status = file_data_source->Initialize(url);
   DataSource* data_source =
       (status == PIPELINE_OK) ? file_data_source.get() : NULL;
-  callback.Run(status, data_source);
+  callback->Run(status, data_source);
+  delete callback;
 }
 
 DataSourceFactory* FileDataSourceFactory::Clone() const {
diff --git a/media/filters/file_data_source_factory.h b/media/filters/file_data_source_factory.h
index ff25484..18c0587 100644
--- a/media/filters/file_data_source_factory.h
+++ b/media/filters/file_data_source_factory.h
@@ -5,7 +5,6 @@
 #ifndef MEDIA_FILTERS_FILE_DATA_SOURCE_FACTORY_H_
 #define MEDIA_FILTERS_FILE_DATA_SOURCE_FACTORY_H_
 
-#include "base/compiler_specific.h"
 #include "media/base/filter_factories.h"
 
 namespace media {
@@ -16,8 +15,8 @@ class FileDataSourceFactory : public DataSourceFactory {
   virtual ~FileDataSourceFactory();
 
   // DataSourceFactory methods.
-  virtual void Build(const std::string& url, const BuildCB& callback) OVERRIDE;
-  virtual DataSourceFactory* Clone() const OVERRIDE;
+  virtual void Build(const std::string& url, BuildCallback* callback);
+  virtual DataSourceFactory* Clone() const;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(FileDataSourceFactory);
diff --git a/media/media.gyp b/media/media.gyp
index 5a718d3..d024f57 100644
--- a/media/media.gyp
+++ b/media/media.gyp
@@ -74,6 +74,8 @@
         'audio/win/wavein_input_win.h',
         'audio/win/waveout_output_win.cc',
         'audio/win/waveout_output_win.h',
+        'base/async_filter_factory_base.cc',
+        'base/async_filter_factory_base.h',
         'base/audio_decoder_config.h',
         'base/bitstream_buffer.h',
         'base/buffers.cc',