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

9 files changed, 122 insertions, 371 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.
diff --git a/media/filters/ffmpeg_demuxer_factory.cc b/media/filters/ffmpeg_demuxer_factory.cc
index 24e58dc..b42d09e 100644
--- a/media/filters/ffmpeg_demuxer_factory.cc
+++ b/media/filters/ffmpeg_demuxer_factory.cc
@@ -2,6 +2,7 @@
 // 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"
@@ -15,11 +16,11 @@ FFmpegDemuxerFactory::FFmpegDemuxerFactory(
 
 FFmpegDemuxerFactory::~FFmpegDemuxerFactory() {}
 
-// This and the next class are one-offs whose raison d'etre is the lack of
+// This class is a one-off whose raison d'etre is the lack of
 // currying functionality in base/callback_old.h's machinery.  Once media/
-// 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().
+// DemuxerFactory::BuildCallback is migrated to the new base/callback.h
+// machinery this should be removed and replaced with currying calls to
+// base::Bind().
 class DemuxerCallbackAsPipelineStatusCallback : public PipelineStatusCallback {
  public:
   DemuxerCallbackAsPipelineStatusCallback(
@@ -42,43 +43,25 @@ class DemuxerCallbackAsPipelineStatusCallback : public PipelineStatusCallback {
   DISALLOW_IMPLICIT_CONSTRUCTORS(DemuxerCallbackAsPipelineStatusCallback);
 };
 
-// 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_);
+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;
   }
-
-  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);
-};
+  DCHECK(data_source);
+  scoped_refptr<FFmpegDemuxer> demuxer = new FFmpegDemuxer(loop);
+  demuxer->Initialize(
+      data_source,
+      new DemuxerCallbackAsPipelineStatusCallback(cb.release(), demuxer));
+}
 
 void FFmpegDemuxerFactory::Build(const std::string& url, BuildCallback* cb) {
-  data_source_factory_->Build(
-      url, new DemuxerCallbackAsDataSourceCallback(cb, loop_));
+  data_source_factory_->Build(url,
+                              base::Bind(&DataSourceFactoryDone, 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 823fa01..91e1208 100644
--- a/media/filters/file_data_source_factory.cc
+++ b/media/filters/file_data_source_factory.cc
@@ -14,13 +14,11 @@ FileDataSourceFactory::FileDataSourceFactory() {}
 FileDataSourceFactory::~FileDataSourceFactory() {}
 
 void FileDataSourceFactory::Build(const std::string& url,
-                                  BuildCallback* callback) {
-  DCHECK(callback);
+                                  const BuildCB& callback) {
+  DCHECK(!callback.is_null());
 
   if (url.empty()) {
-    callback->Run(media::PIPELINE_ERROR_URL_NOT_FOUND,
-                  static_cast<media::DataSource*>(NULL));
-    delete callback;
+    callback.Run(media::PIPELINE_ERROR_URL_NOT_FOUND, NULL);
     return;
   }
 
@@ -29,8 +27,7 @@ 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);
-  delete callback;
+  callback.Run(status, data_source);
 }
 
 DataSourceFactory* FileDataSourceFactory::Clone() const {
diff --git a/media/filters/file_data_source_factory.h b/media/filters/file_data_source_factory.h
index 18c0587..ff25484 100644
--- a/media/filters/file_data_source_factory.h
+++ b/media/filters/file_data_source_factory.h
@@ -5,6 +5,7 @@
 #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 {
@@ -15,8 +16,8 @@ class FileDataSourceFactory : public DataSourceFactory {
   virtual ~FileDataSourceFactory();
 
   // DataSourceFactory methods.
-  virtual void Build(const std::string& url, BuildCallback* callback);
-  virtual DataSourceFactory* Clone() const;
+  virtual void Build(const std::string& url, const BuildCB& callback) OVERRIDE;
+  virtual DataSourceFactory* Clone() const OVERRIDE;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(FileDataSourceFactory);
diff --git a/media/media.gyp b/media/media.gyp
index d024f57..5a718d3 100644
--- a/media/media.gyp
+++ b/media/media.gyp
@@ -74,8 +74,6 @@
         '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',