Callback renaming in media code.

This is a follow up CL of 125959.

- Rename AudioTimeCB and VideoTimeCB to TimeCB, as the context (VideoRenderer/AudioRenderer already provides clear context).
- Rename PipelineStatusCB callback variable names to status_cb if no names with specific meaning (e.g. seek_cb) are given.
- Rename foo_callback to foo_cb (except for media/audio/).

Note that media/audio also contains a lot of FooCallback types and foo_callback names. This will probably be addressed in another CL.

BUG=none
TEST=none


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

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

12 files changed, 149 insertions, 149 deletions

diff --git a/media/base/audio_decoder.h b/media/base/audio_decoder.h
index 3b41694..e435a1c 100644
--- a/media/base/audio_decoder.h
+++ b/media/base/audio_decoder.h
@@ -23,7 +23,7 @@ class MEDIA_EXPORT AudioDecoder
   // callback upon completion.
   // statistics_cb is used to update global pipeline statistics.
   virtual void Initialize(const scoped_refptr<DemuxerStream>& stream,
-                          const PipelineStatusCB& callback,
+                          const PipelineStatusCB& status_cb,
                           const StatisticsCB& statistics_cb) = 0;
 
   // Request samples to be decoded and returned via the provided callback.
diff --git a/media/base/composite_filter.cc b/media/base/composite_filter.cc
index 235a810..d766948 100644
--- a/media/base/composite_filter.cc
+++ b/media/base/composite_filter.cc
@@ -88,71 +88,71 @@ FilterHost* CompositeFilter::host() {
   return host_impl_.get() ? host_impl_->host() : NULL;
 }
 
-void CompositeFilter::Play(const base::Closure& play_callback) {
+void CompositeFilter::Play(const base::Closure& play_cb) {
   DCHECK_EQ(message_loop_, MessageLoop::current());
   if (IsOperationPending()) {
     SendErrorToHost(PIPELINE_ERROR_OPERATION_PENDING);
-    play_callback.Run();
+    play_cb.Run();
     return;
   } else if (state_ == kPlaying) {
-    play_callback.Run();
+    play_cb.Run();
     return;
   } else if (!host() || (state_ != kPaused && state_ != kCreated)) {
     SendErrorToHost(PIPELINE_ERROR_INVALID_STATE);
-    play_callback.Run();
+    play_cb.Run();
     return;
   }
 
   ChangeState(kPlayPending);
-  callback_ = play_callback;
+  callback_ = play_cb;
   StartSerialCallSequence();
 }
 
-void CompositeFilter::Pause(const base::Closure& pause_callback) {
+void CompositeFilter::Pause(const base::Closure& pause_cb) {
   DCHECK_EQ(message_loop_, MessageLoop::current());
   if (IsOperationPending()) {
     SendErrorToHost(PIPELINE_ERROR_OPERATION_PENDING);
-    pause_callback.Run();
+    pause_cb.Run();
     return;
   } else if (state_ == kPaused) {
-    pause_callback.Run();
+    pause_cb.Run();
     return;
   } else if (!host() || state_ != kPlaying) {
     SendErrorToHost(PIPELINE_ERROR_INVALID_STATE);
-    pause_callback.Run();
+    pause_cb.Run();
     return;
   }
 
   ChangeState(kPausePending);
-  callback_ = pause_callback;
+  callback_ = pause_cb;
   StartSerialCallSequence();
 }
 
-void CompositeFilter::Flush(const base::Closure& flush_callback) {
+void CompositeFilter::Flush(const base::Closure& flush_cb) {
   DCHECK_EQ(message_loop_, MessageLoop::current());
   if (IsOperationPending()) {
     SendErrorToHost(PIPELINE_ERROR_OPERATION_PENDING);
-    flush_callback.Run();
+    flush_cb.Run();
     return;
   } else if (!host() || (state_ != kCreated && state_ != kPaused)) {
     SendErrorToHost(PIPELINE_ERROR_INVALID_STATE);
-    flush_callback.Run();
+    flush_cb.Run();
     return;
   }
 
   ChangeState(kFlushPending);
-  callback_ = flush_callback;
+  callback_ = flush_cb;
   StartParallelCallSequence();
 }
 
-void CompositeFilter::Stop(const base::Closure& stop_callback) {
+void CompositeFilter::Stop(const base::Closure& stop_cb) {
   DCHECK_EQ(message_loop_, MessageLoop::current());
   if (!host()) {
     SendErrorToHost(PIPELINE_ERROR_INVALID_STATE);
-    stop_callback.Run();
+    stop_cb.Run();
     return;
   } else if (state_ == kStopped) {
-    stop_callback.Run();
+    stop_cb.Run();
     return;
   }
 
@@ -177,7 +177,7 @@ void CompositeFilter::Stop(const base::Closure& stop_callback) {
       break;
     default:
       SendErrorToHost(PIPELINE_ERROR_INVALID_STATE);
-      stop_callback.Run();
+      stop_cb.Run();
       return;
   }
 
@@ -186,7 +186,7 @@ void CompositeFilter::Stop(const base::Closure& stop_callback) {
     status_cb_.Reset();
   }
 
-  callback_ = stop_callback;
+  callback_ = stop_cb;
   if (state_ == kStopPending) {
     StartSerialCallSequence();
   }
diff --git a/media/base/composite_filter.h b/media/base/composite_filter.h
index 9821d03f..5bd2e78 100644
--- a/media/base/composite_filter.h
+++ b/media/base/composite_filter.h
@@ -1,4 +1,4 @@
-// Copyright (c) 2011 The Chromium Authors. All rights reserved.
+// 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.
 
@@ -33,10 +33,10 @@ class MEDIA_EXPORT CompositeFilter : public Filter {
   // media::Filter methods.
   virtual void set_host(FilterHost* host) OVERRIDE;
   virtual FilterHost* host() OVERRIDE;
-  virtual void Play(const base::Closure& play_callback) OVERRIDE;
-  virtual void Pause(const base::Closure& pause_callback) OVERRIDE;
-  virtual void Flush(const base::Closure& flush_callback) OVERRIDE;
-  virtual void Stop(const base::Closure& stop_callback) OVERRIDE;
+  virtual void Play(const base::Closure& play_cb) OVERRIDE;
+  virtual void Pause(const base::Closure& pause_cb) OVERRIDE;
+  virtual void Flush(const base::Closure& flush_cb) OVERRIDE;
+  virtual void Stop(const base::Closure& stop_cb) OVERRIDE;
   virtual void SetPlaybackRate(float playback_rate) OVERRIDE;
   virtual void Seek(
       base::TimeDelta time, const FilterStatusCB& seek_cb) OVERRIDE;
diff --git a/media/base/composite_filter_unittest.cc b/media/base/composite_filter_unittest.cc
index 1072fc8..385d00c 100644
--- a/media/base/composite_filter_unittest.cc
+++ b/media/base/composite_filter_unittest.cc
@@ -89,16 +89,16 @@ class CompositeFilterTest : public testing::Test {
   void ExpectInvalidStateFail(MethodToCall method_to_call,
                   base::TimeDelta seek_time = base::TimeDelta());
 
-  // Returns whether |filter_1_callback_| or |filter_1_status_cb_| is set.
+  // Returns whether |filter_1_cb_| or |filter_1_status_cb_| is set.
   bool HasFilter1Callback() const;
 
-  // Run the callback stored in |filter_1_callback_| or |filter_2_status_cb_|.
+  // Run the callback stored in |filter_1_cb_| or |filter_2_status_cb_|.
   void RunFilter1Callback();
 
-  // Returns whether |filter_2_callback_| or |filter_2_status_cb_| is set.
+  // Returns whether |filter_2_cb_| or |filter_2_status_cb_| is set.
   bool HasFilter2Callback() const;
 
-  // Run the callback stored in |filter_2_callback_| or |filter_2_status_cb_|.
+  // Run the callback stored in |filter_2_cb_| or |filter_2_status_cb_|.
   void RunFilter2Callback();
 
  protected:
@@ -112,7 +112,7 @@ class CompositeFilterTest : public testing::Test {
 
   // Callback passed to |filter_1_| during last Play(), Pause(), Flush(),
   // or Stop() call.
-  base::Closure filter_1_callback_;
+  base::Closure filter_1_cb_;
 
   // Status to pass to |filter_1_status_cb_|.
   PipelineStatus filter_1_status_;
@@ -125,7 +125,7 @@ class CompositeFilterTest : public testing::Test {
 
   // Callback passed to |filter_2_| during last Play(), Pause(), Flush(),
   // Stop(), or Seek() call.
-  base::Closure filter_2_callback_;
+  base::Closure filter_2_cb_;
 
   // Status to pass to |filter_2_status_cb_|.
   PipelineStatus filter_2_status_;
@@ -154,36 +154,36 @@ void CompositeFilterTest::SetupAndAdd2Filters() {
   composite_->set_host(mock_filter_host_.get());
 
   // Setup |filter_1_| and arrange for methods to set
-  // |filter_1_callback_| when they are called.
+  // |filter_1_cb_| when they are called.
   filter_1_ = new StrictMock<MockFilter>();
-  filter_1_callback_.Reset();
+  filter_1_cb_.Reset();
   filter_1_status_ = PIPELINE_OK;
   filter_1_status_cb_.Reset();
   ON_CALL(*filter_1_, Play(_))
-      .WillByDefault(SaveArg<0>(&filter_1_callback_));
+      .WillByDefault(SaveArg<0>(&filter_1_cb_));
   ON_CALL(*filter_1_, Pause(_))
-      .WillByDefault(SaveArg<0>(&filter_1_callback_));
+      .WillByDefault(SaveArg<0>(&filter_1_cb_));
   ON_CALL(*filter_1_, Flush(_))
-      .WillByDefault(SaveArg<0>(&filter_1_callback_));
+      .WillByDefault(SaveArg<0>(&filter_1_cb_));
   ON_CALL(*filter_1_, Stop(_))
-      .WillByDefault(SaveArg<0>(&filter_1_callback_));
+      .WillByDefault(SaveArg<0>(&filter_1_cb_));
   ON_CALL(*filter_1_, Seek(_,_))
       .WillByDefault(SaveArg<1>(&filter_1_status_cb_));
 
   // Setup |filter_2_| and arrange for methods to set
-  // |filter_2_callback_| when they are called.
+  // |filter_2_cb_| when they are called.
   filter_2_ = new StrictMock<MockFilter>();
-  filter_2_callback_.Reset();
+  filter_2_cb_.Reset();
   filter_2_status_ = PIPELINE_OK;
   filter_2_status_cb_.Reset();
   ON_CALL(*filter_2_, Play(_))
-      .WillByDefault(SaveArg<0>(&filter_2_callback_));
+      .WillByDefault(SaveArg<0>(&filter_2_cb_));
   ON_CALL(*filter_2_, Pause(_))
-      .WillByDefault(SaveArg<0>(&filter_2_callback_));
+      .WillByDefault(SaveArg<0>(&filter_2_cb_));
   ON_CALL(*filter_2_, Flush(_))
-      .WillByDefault(SaveArg<0>(&filter_2_callback_));
+      .WillByDefault(SaveArg<0>(&filter_2_cb_));
   ON_CALL(*filter_2_, Stop(_))
-      .WillByDefault(SaveArg<0>(&filter_2_callback_));
+      .WillByDefault(SaveArg<0>(&filter_2_cb_));
   ON_CALL(*filter_2_, Seek(_,_))
       .WillByDefault(SaveArg<1>(&filter_2_status_cb_));
 
@@ -328,8 +328,8 @@ void CompositeFilterTest::ExpectInvalidStateFail(MethodToCall method_to_call,
 }
 
 bool CompositeFilterTest::HasFilter1Callback() const {
-  CHECK(filter_1_callback_.is_null() || filter_1_status_cb_.is_null());
-  return !filter_1_callback_.is_null() || !filter_1_status_cb_.is_null();
+  CHECK(filter_1_cb_.is_null() || filter_1_status_cb_.is_null());
+  return !filter_1_cb_.is_null() || !filter_1_status_cb_.is_null();
 }
 
 void CompositeFilterTest::RunFilter1Callback() {
@@ -341,15 +341,15 @@ void CompositeFilterTest::RunFilter1Callback() {
     return;
   }
 
-  EXPECT_TRUE(!filter_1_callback_.is_null());
-  base::Closure callback = filter_1_callback_;
-  filter_1_callback_.Reset();
+  EXPECT_TRUE(!filter_1_cb_.is_null());
+  base::Closure callback = filter_1_cb_;
+  filter_1_cb_.Reset();
   callback.Run();
 }
 
 bool CompositeFilterTest::HasFilter2Callback() const {
-  CHECK(filter_2_callback_.is_null() || filter_2_status_cb_.is_null());
-  return !filter_2_callback_.is_null() || !filter_2_status_cb_.is_null();
+  CHECK(filter_2_cb_.is_null() || filter_2_status_cb_.is_null());
+  return !filter_2_cb_.is_null() || !filter_2_status_cb_.is_null();
 }
 
 void CompositeFilterTest::RunFilter2Callback() {
@@ -361,9 +361,9 @@ void CompositeFilterTest::RunFilter2Callback() {
     return;
   }
 
-  EXPECT_FALSE(filter_2_callback_.is_null());
-  base::Closure callback = filter_2_callback_;
-  filter_2_callback_.Reset();
+  EXPECT_FALSE(filter_2_cb_.is_null());
+  base::Closure callback = filter_2_cb_;
+  filter_2_cb_.Reset();
   callback.Run();
 }
 
@@ -539,7 +539,7 @@ TEST_F(CompositeFilterTest, TestPauseErrors) {
 
   RunFilter1Callback();
 
-  // Make sure |filter_2_callback_| was not set.
+  // Make sure |filter_2_cb_| was not set.
   EXPECT_FALSE(HasFilter2Callback());
 
   // Verify that Play/Pause/Flush/Seek fail now that an error occured.
diff --git a/media/base/demuxer.cc b/media/base/demuxer.cc
index b6b2d18..f3aa340 100644
--- a/media/base/demuxer.cc
+++ b/media/base/demuxer.cc
@@ -1,4 +1,4 @@
-// Copyright (c) 2011 The Chromium Authors. All rights reserved.
+// 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.
 
@@ -22,9 +22,9 @@ void Demuxer::set_host(DemuxerHost* host) {
 
 void Demuxer::SetPlaybackRate(float playback_rate) {}
 
-void Demuxer::Seek(base::TimeDelta time, const PipelineStatusCB& callback) {
-  DCHECK(!callback.is_null());
-  callback.Run(PIPELINE_OK);
+void Demuxer::Seek(base::TimeDelta time, const PipelineStatusCB& status_cb) {
+  DCHECK(!status_cb.is_null());
+  status_cb.Run(PIPELINE_OK);
 }
 
 void Demuxer::Stop(const base::Closure& callback) {
diff --git a/media/base/demuxer.h b/media/base/demuxer.h
index f049f6f..d60e793 100644
--- a/media/base/demuxer.h
+++ b/media/base/demuxer.h
@@ -1,4 +1,4 @@
-// Copyright (c) 2011 The Chromium Authors. All rights reserved.
+// 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.
 
@@ -52,7 +52,7 @@ class MEDIA_EXPORT Demuxer
 
   // Carry out any actions required to seek to the given time, executing the
   // callback upon completion.
-  virtual void Seek(base::TimeDelta time, const PipelineStatusCB& callback);
+  virtual void Seek(base::TimeDelta time, const PipelineStatusCB& status_cb);
 
   // The pipeline is being stopped either as a result of an error or because
   // the client called Stop().
diff --git a/media/base/filters.h b/media/base/filters.h
index 50dc686..242af5c 100644
--- a/media/base/filters.h
+++ b/media/base/filters.h
@@ -124,7 +124,7 @@ class MEDIA_EXPORT VideoDecoder : public Filter {
   // callback upon completion.
   // statistics_cb is used to update global pipeline statistics.
   virtual void Initialize(DemuxerStream* stream,
-                          const PipelineStatusCB& callback,
+                          const PipelineStatusCB& status_cb,
                           const StatisticsCB& statistics_cb) = 0;
 
   // Request a frame to be decoded and returned via the provided callback.
@@ -171,14 +171,14 @@ class MEDIA_EXPORT VideoRenderer : public Filter {
  public:
   // Used to update the pipeline's clock time. The parameter is the time that
   // the clock should not exceed.
-  typedef base::Callback<void(base::TimeDelta)> VideoTimeCB;
+  typedef base::Callback<void(base::TimeDelta)> TimeCB;
 
   // Initialize a VideoRenderer with the given VideoDecoder, executing the
   // callback upon completion.
   virtual void Initialize(VideoDecoder* decoder,
-                          const PipelineStatusCB& callback,
+                          const PipelineStatusCB& status_cb,
                           const StatisticsCB& statistics_cb,
-                          const VideoTimeCB& time_cb) = 0;
+                          const TimeCB& time_cb) = 0;
 
   // Returns true if this filter has received and processed an end-of-stream
   // buffer.
@@ -191,18 +191,18 @@ class MEDIA_EXPORT AudioRenderer : public Filter {
   // Used to update the pipeline's clock time. The first parameter is the
   // current time, and the second parameter is the time that the clock must not
   // exceed.
-  typedef base::Callback<void(base::TimeDelta, base::TimeDelta)> AudioTimeCB;
+  typedef base::Callback<void(base::TimeDelta, base::TimeDelta)> TimeCB;
 
   // Initialize a AudioRenderer with the given AudioDecoder, executing the
-  // |init_callback| upon completion. |underflow_callback| is called when the
+  // |init_cb| upon completion. |underflow_cb| is called when the
   // renderer runs out of data to pass to the audio card during playback.
-  // If the |underflow_callback| is called ResumeAfterUnderflow() must be called
+  // If the |underflow_cb| is called ResumeAfterUnderflow() must be called
   // to resume playback. Pause(), Seek(), or Stop() cancels the underflow
   // condition.
   virtual void Initialize(const scoped_refptr<AudioDecoder>& decoder,
-                          const PipelineStatusCB& init_callback,
-                          const base::Closure& underflow_callback,
-                          const AudioTimeCB& time_cb) = 0;
+                          const PipelineStatusCB& init_cb,
+                          const base::Closure& underflow_cb,
+                          const TimeCB& time_cb) = 0;
 
   // Returns true if this filter has received and processed an end-of-stream
   // buffer.
diff --git a/media/base/mock_filters.cc b/media/base/mock_filters.cc
index 74d80e6..08d663a 100644
--- a/media/base/mock_filters.cc
+++ b/media/base/mock_filters.cc
@@ -130,7 +130,7 @@ MockFilterCollection::~MockFilterCollection() {}
 
 scoped_ptr<FilterCollection> MockFilterCollection::filter_collection(
     bool include_demuxer,
-    bool run_build_callback,
+    bool run_build_cb,
     bool run_build,
     PipelineStatus build_status) const {
   scoped_ptr<FilterCollection> collection(new FilterCollection());
@@ -141,7 +141,7 @@ scoped_ptr<FilterCollection> MockFilterCollection::filter_collection(
   if (build_status != PIPELINE_OK)
     demuxer_factory->SetError(build_status);
 
-  if (run_build_callback) {
+  if (run_build_cb) {
     ON_CALL(*demuxer_factory, Build(_, _)).WillByDefault(Invoke(
         demuxer_factory.get(), &MockDemuxerFactory::RunBuildCallback));
   }  // else ignore Build calls.
@@ -170,14 +170,14 @@ void RunPipelineStatusCB(PipelineStatus status, const PipelineStatusCB& cb) {
   cb.Run(status);
 }
 
-void RunPipelineStatusCB3(::testing::Unused, const PipelineStatusCB& callback,
+void RunPipelineStatusCB3(::testing::Unused, const PipelineStatusCB& status_cb,
                           ::testing::Unused) {
-  callback.Run(PIPELINE_OK);
+  status_cb.Run(PIPELINE_OK);
 }
 
-void RunPipelineStatusCB4(::testing::Unused, const PipelineStatusCB& callback,
+void RunPipelineStatusCB4(::testing::Unused, const PipelineStatusCB& status_cb,
                           ::testing::Unused, ::testing::Unused) {
-  callback.Run(PIPELINE_OK);
+  status_cb.Run(PIPELINE_OK);
 }
 
 void RunStopFilterCallback(const base::Closure& callback) {
diff --git a/media/base/mock_filters.h b/media/base/mock_filters.h
index d1a472a..3b1d77f 100644
--- a/media/base/mock_filters.h
+++ b/media/base/mock_filters.h
@@ -187,7 +187,7 @@ class MockVideoDecoder : public VideoDecoder {
 
   // VideoDecoder implementation.
   MOCK_METHOD3(Initialize, void(DemuxerStream* stream,
-                                const PipelineStatusCB& callback,
+                                const PipelineStatusCB& status_cb,
                                 const StatisticsCB& statistics_cb));
   MOCK_METHOD1(Read, void(const ReadCB& read_cb));
   MOCK_METHOD0(natural_size, const gfx::Size&());
@@ -234,9 +234,9 @@ class MockVideoRenderer : public VideoRenderer {
 
   // VideoRenderer implementation.
   MOCK_METHOD4(Initialize, void(VideoDecoder* decoder,
-                                const PipelineStatusCB& callback,
+                                const PipelineStatusCB& status_cb,
                                 const StatisticsCB& statistics_cb,
-                                const VideoTimeCB& time_cb));
+                                const TimeCB& time_cb));
 
   MOCK_METHOD0(HasEnded, bool());
 
@@ -263,9 +263,9 @@ class MockAudioRenderer : public AudioRenderer {
 
   // AudioRenderer implementation.
   MOCK_METHOD4(Initialize, void(const scoped_refptr<AudioDecoder>& decoder,
-                                const PipelineStatusCB& init_callback,
-                                const base::Closure& underflow_callback,
-                                const AudioTimeCB& time_cb));
+                                const PipelineStatusCB& init_cb,
+                                const base::Closure& underflow_cb,
+                                const TimeCB& time_cb));
   MOCK_METHOD0(HasEnded, bool());
   MOCK_METHOD1(SetVolume, void(float volume));
 
@@ -297,7 +297,7 @@ class MockFilterCollection {
   }
 
   scoped_ptr<FilterCollection> filter_collection(
-      bool include_demuxer, bool run_build_callback, bool run_build,
+      bool include_demuxer, bool run_build_cb, bool run_build,
       PipelineStatus build_status) const;
 
  private:
@@ -316,9 +316,9 @@ class MockFilterCollection {
 void RunFilterCallback(::testing::Unused, const base::Closure& callback);
 void RunFilterStatusCB(::testing::Unused, const FilterStatusCB& cb);
 void RunPipelineStatusCB(PipelineStatus status, const PipelineStatusCB& cb);
-void RunPipelineStatusCB3(::testing::Unused, const PipelineStatusCB& callback,
+void RunPipelineStatusCB3(::testing::Unused, const PipelineStatusCB& status_cb,
                           ::testing::Unused);
-void RunPipelineStatusCB4(::testing::Unused, const PipelineStatusCB& callback,
+void RunPipelineStatusCB4(::testing::Unused, const PipelineStatusCB& status_cb,
                           ::testing::Unused, ::testing::Unused);
 // Helper gmock function that immediately executes the Closure on behalf of the
 // provided filter.  Can be used when mocking the Stop() method.
diff --git a/media/base/pipeline.cc b/media/base/pipeline.cc
index 9da3df1..c7754bd 100644
--- a/media/base/pipeline.cc
+++ b/media/base/pipeline.cc
@@ -90,37 +90,37 @@ Pipeline::~Pipeline() {
 
 void Pipeline::Start(scoped_ptr<FilterCollection> collection,
                      const std::string& url,
-                     const PipelineStatusCB& ended_callback,
-                     const PipelineStatusCB& error_callback,
-                     const NetworkEventCB& network_callback,
-                     const PipelineStatusCB& start_callback) {
+                     const PipelineStatusCB& ended_cb,
+                     const PipelineStatusCB& error_cb,
+                     const NetworkEventCB& network_cb,
+                     const PipelineStatusCB& start_cb) {
   base::AutoLock auto_lock(lock_);
   CHECK(!running_) << "Media pipeline is already running";
 
   running_ = true;
   message_loop_->PostTask(FROM_HERE, base::Bind(
       &Pipeline::StartTask, this, base::Passed(&collection),
-      url, ended_callback, error_callback, network_callback, start_callback));
+      url, ended_cb, error_cb, network_cb, start_cb));
 }
 
-void Pipeline::Stop(const PipelineStatusCB& stop_callback) {
+void Pipeline::Stop(const PipelineStatusCB& stop_cb) {
   base::AutoLock auto_lock(lock_);
   CHECK(running_) << "Media pipeline isn't running";
 
   // Stop the pipeline, which will set |running_| to false on our behalf.
   message_loop_->PostTask(FROM_HERE, base::Bind(
-      &Pipeline::StopTask, this, stop_callback));
+      &Pipeline::StopTask, this, stop_cb));
 }
 
 void Pipeline::Seek(base::TimeDelta time,
-                    const PipelineStatusCB& seek_callback) {
+                    const PipelineStatusCB& seek_cb) {
   base::AutoLock auto_lock(lock_);
   CHECK(running_) << "Media pipeline isn't running";
 
   download_rate_monitor_.Stop();
 
   message_loop_->PostTask(FROM_HERE, base::Bind(
-      &Pipeline::SeekTask, this, time, seek_callback));
+      &Pipeline::SeekTask, this, time, seek_cb));
 }
 
 bool Pipeline::IsRunning() const {
@@ -381,9 +381,9 @@ void Pipeline::FinishInitialization() {
   DCHECK_EQ(MessageLoop::current(), message_loop_);
   // Execute the seek callback, if present.  Note that this might be the
   // initial callback passed into Start().
-  if (!seek_callback_.is_null()) {
-    seek_callback_.Run(status_);
-    seek_callback_.Reset();
+  if (!seek_cb_.is_null()) {
+    seek_cb_.Run(status_);
+    seek_cb_.Reset();
   }
 }
 
@@ -602,18 +602,18 @@ void Pipeline::OnUpdateStatistics(const PipelineStatistics& stats) {
 
 void Pipeline::StartTask(scoped_ptr<FilterCollection> filter_collection,
                          const std::string& url,
-                         const PipelineStatusCB& ended_callback,
-                         const PipelineStatusCB& error_callback,
-                         const NetworkEventCB& network_callback,
-                         const PipelineStatusCB& start_callback) {
+                         const PipelineStatusCB& ended_cb,
+                         const PipelineStatusCB& error_cb,
+                         const NetworkEventCB& network_cb,
+                         const PipelineStatusCB& start_cb) {
   DCHECK_EQ(MessageLoop::current(), message_loop_);
   DCHECK_EQ(kCreated, state_);
   filter_collection_ = filter_collection.Pass();
   url_ = url;
-  ended_callback_ = ended_callback;
-  error_callback_ = error_callback;
-  network_callback_ = network_callback;
-  seek_callback_ = start_callback;
+  ended_cb_ = ended_cb;
+  error_cb_ = error_cb;
+  network_cb_ = network_cb;
+  seek_cb_ = start_cb;
 
   // Kick off initialization.
   pipeline_init_state_.reset(new PipelineInitState());
@@ -636,7 +636,7 @@ void Pipeline::StartTask(scoped_ptr<FilterCollection> filter_collection,
 //
 // When all required filters have been created and have called their
 // FilterHost's InitializationComplete() method, the pipeline will update its
-// state to kStarted and |init_callback_|, will be executed.
+// state to kStarted and |init_cb_|, will be executed.
 //
 // TODO(hclam): InitializeTask() is now starting the pipeline asynchronously. It
 // works like a big state change table. If we no longer need to start filters
@@ -746,7 +746,7 @@ void Pipeline::InitializeTask(PipelineStatus last_stage_status) {
 // TODO(scherkus): beware!  this can get posted multiple times since we post
 // Stop() tasks even if we've already stopped.  Perhaps this should no-op for
 // additional calls, however most of this logic will be changing.
-void Pipeline::StopTask(const PipelineStatusCB& stop_callback) {
+void Pipeline::StopTask(const PipelineStatusCB& stop_cb) {
   DCHECK_EQ(MessageLoop::current(), message_loop_);
   DCHECK(!IsPipelineStopPending());
   DCHECK_NE(state_, kStopped);
@@ -758,13 +758,13 @@ void Pipeline::StopTask(const PipelineStatusCB& stop_callback) {
 
   if (state_ == kStopped) {
     // Already stopped so just run callback.
-    stop_callback.Run(status_);
+    stop_cb.Run(status_);
     return;
   }
 
   if (IsPipelineTearingDown() && error_caused_teardown_) {
     // If we are stopping due to SetError(), stop normally instead of
-    // going to error state and calling |error_callback_|. This converts
+    // going to error state and calling |error_cb_|. This converts
     // the teardown in progress from an error teardown into one that acts
     // like the error never occurred.
     base::AutoLock auto_lock(lock_);
@@ -772,7 +772,7 @@ void Pipeline::StopTask(const PipelineStatusCB& stop_callback) {
     error_caused_teardown_ = false;
   }
 
-  stop_callback_ = stop_callback;
+  stop_cb_ = stop_cb;
 
   stop_pending_ = true;
   if (!IsPipelineSeeking() && !IsPipelineTearingDown()) {
@@ -855,7 +855,7 @@ void Pipeline::PreloadChangedTask(Preload preload) {
 }
 
 void Pipeline::SeekTask(base::TimeDelta time,
-                        const PipelineStatusCB& seek_callback) {
+                        const PipelineStatusCB& seek_cb) {
   DCHECK_EQ(MessageLoop::current(), message_loop_);
   DCHECK(!IsPipelineStopPending());
 
@@ -880,7 +880,7 @@ void Pipeline::SeekTask(base::TimeDelta time,
   //   kStarted
   SetState(kPausing);
   seek_timestamp_ = time;
-  seek_callback_ = seek_callback;
+  seek_cb_ = seek_cb;
 
   // Kick off seeking!
   {
@@ -926,15 +926,15 @@ void Pipeline::NotifyEndedTask() {
     clock_->EndOfStream();
   }
 
-  if (!ended_callback_.is_null()) {
-    ended_callback_.Run(status_);
+  if (!ended_cb_.is_null()) {
+    ended_cb_.Run(status_);
   }
 }
 
 void Pipeline::NotifyNetworkEventTask(NetworkEvent type) {
   DCHECK_EQ(MessageLoop::current(), message_loop_);
-  if (!network_callback_.is_null())
-    network_callback_.Run(type);
+  if (!network_cb_.is_null())
+    network_cb_.Run(type);
 }
 
 void Pipeline::DisableAudioRendererTask() {
@@ -1098,14 +1098,14 @@ void Pipeline::FinishDestroyingFiltersTask() {
 
   pipeline_filter_ = NULL;
 
-  if (error_caused_teardown_ && !IsPipelineOk() && !error_callback_.is_null())
-    error_callback_.Run(status_);
+  if (error_caused_teardown_ && !IsPipelineOk() && !error_cb_.is_null())
+    error_cb_.Run(status_);
 
   if (stop_pending_) {
     stop_pending_ = false;
     ResetState();
     PipelineStatusCB stop_cb;
-    std::swap(stop_cb, stop_callback_);
+    std::swap(stop_cb, stop_cb_);
     // Notify the client that stopping has finished.
     if (!stop_cb.is_null()) {
       stop_cb.Run(status_);
diff --git a/media/base/pipeline.h b/media/base/pipeline.h
index c960912..659199f 100644
--- a/media/base/pipeline.h
+++ b/media/base/pipeline.h
@@ -122,12 +122,12 @@ class MEDIA_EXPORT Pipeline
   //
   // Pipeline initialization is an inherently asynchronous process.  Clients can
   // either poll the IsInitialized() method (discouraged) or optionally pass in
-  // |start_callback|, which will be executed when initialization completes.
+  // |start_cb|, which will be executed when initialization completes.
   //
   // The following permanent callbacks will be executed as follows:
-  //   |ended_callback| will be executed whenever the media reaches the end.
-  //   |error_callback_| will be executed whenever an error occurs.
-  //   |network_callback_| will be executed whenever there's a network activity.
+  //   |ended_cb| will be executed whenever the media reaches the end.
+  //   |error_cb_| will be executed whenever an error occurs.
+  //   |network_cb_| will be executed whenever there's a network activity.
   //
   // These callbacks are only executed after Start() has been called and until
   // Stop() has completed.
@@ -137,14 +137,14 @@ class MEDIA_EXPORT Pipeline
   // TODO(scherkus): remove IsInitialized() and force clients to use callbacks.
   void Start(scoped_ptr<FilterCollection> filter_collection,
              const std::string& url,
-             const PipelineStatusCB& ended_callback,
-             const PipelineStatusCB& error_callback,
-             const NetworkEventCB& network_callback,
-             const PipelineStatusCB& start_callback);
+             const PipelineStatusCB& ended_cb,
+             const PipelineStatusCB& error_cb,
+             const NetworkEventCB& network_cb,
+             const PipelineStatusCB& start_cb);
 
   // Asynchronously stops the pipeline and resets it to an uninitialized state.
   //
-  // If provided, |stop_callback| will be executed when the pipeline has been
+  // If provided, |stop_cb| will be executed when the pipeline has been
   // completely torn down and reset to an uninitialized state.  It is acceptable
   // to call Start() again once the callback has finished executing.
   //
@@ -155,16 +155,16 @@ class MEDIA_EXPORT Pipeline
   //
   // TODO(scherkus): ideally clients would destroy the pipeline after calling
   // Stop() and create a new pipeline as needed.
-  void Stop(const PipelineStatusCB& stop_callback);
+  void Stop(const PipelineStatusCB& stop_cb);
 
-  // Attempt to seek to the position specified by time.  |seek_callback| will be
+  // Attempt to seek to the position specified by time.  |seek_cb| will be
   // executed when the all filters in the pipeline have processed the seek.
   //
   // Clients are expected to call GetCurrentTime() to check whether the seek
   // succeeded.
   //
   // It is an error to call this method if the pipeline has not started.
-  void Seek(base::TimeDelta time, const PipelineStatusCB& seek_callback);
+  void Seek(base::TimeDelta time, const PipelineStatusCB& seek_cb);
 
   // Returns true if the pipeline has been started via Start().  If IsRunning()
   // returns true, it is expected that Stop() will be called before destroying
@@ -353,10 +353,10 @@ class MEDIA_EXPORT Pipeline
   // message loop.
   void StartTask(scoped_ptr<FilterCollection> filter_collection,
                  const std::string& url,
-                 const PipelineStatusCB& ended_callback,
-                 const PipelineStatusCB& error_callback,
-                 const NetworkEventCB& network_callback,
-                 const PipelineStatusCB& start_callback);
+                 const PipelineStatusCB& ended_cb,
+                 const PipelineStatusCB& error_cb,
+                 const NetworkEventCB& network_cb,
+                 const PipelineStatusCB& start_cb);
 
   // InitializeTask() performs initialization in multiple passes. It is executed
   // as a result of calling Start() or InitializationComplete() that advances
@@ -366,7 +366,7 @@ class MEDIA_EXPORT Pipeline
   void InitializeTask(PipelineStatus last_stage_status);
 
   // Stops and destroys all filters, placing the pipeline in the kStopped state.
-  void StopTask(const PipelineStatusCB& stop_callback);
+  void StopTask(const PipelineStatusCB& stop_cb);
 
   // Carries out stopping and destroying all filters, placing the pipeline in
   // the kError state.
@@ -385,7 +385,7 @@ class MEDIA_EXPORT Pipeline
   void PreloadChangedTask(Preload preload);
 
   // Carries out notifying filters that we are seeking to a new timestamp.
-  void SeekTask(base::TimeDelta time, const PipelineStatusCB& seek_callback);
+  void SeekTask(base::TimeDelta time, const PipelineStatusCB& seek_cb);
 
   // Carries out handling a notification from a filter that it has ended.
   void NotifyEndedTask();
@@ -591,11 +591,11 @@ class MEDIA_EXPORT Pipeline
   std::string url_;
 
   // Callbacks for various pipeline operations.
-  PipelineStatusCB seek_callback_;
-  PipelineStatusCB stop_callback_;
-  PipelineStatusCB ended_callback_;
-  PipelineStatusCB error_callback_;
-  NetworkEventCB network_callback_;
+  PipelineStatusCB seek_cb_;
+  PipelineStatusCB stop_cb_;
+  PipelineStatusCB ended_cb_;
+  PipelineStatusCB error_cb_;
+  NetworkEventCB network_cb_;
 
   // Reference to the filter(s) that constitute the pipeline.
   scoped_refptr<Filter> pipeline_filter_;
diff --git a/media/base/pipeline_unittest.cc b/media/base/pipeline_unittest.cc
index 8008f43..83b3c82 100644
--- a/media/base/pipeline_unittest.cc
+++ b/media/base/pipeline_unittest.cc
@@ -159,8 +159,8 @@ class PipelineTest : public ::testing::Test {
   }
 
   // Sets up expectations to allow the audio renderer to initialize.
-  void InitializeAudioRenderer(bool disable_after_init_callback = false) {
-    if (disable_after_init_callback) {
+  void InitializeAudioRenderer(bool disable_after_init_cb = false) {
+    if (disable_after_init_cb) {
       EXPECT_CALL(*mocks_->audio_renderer(), Initialize(
           scoped_refptr<AudioDecoder>(mocks_->audio_decoder()), _, _, _))
           .WillOnce(DoAll(Invoke(&RunPipelineStatusCB4),
@@ -854,25 +854,25 @@ TEST_F(PipelineTest, StartTimeIsNonZero) {
 class FlexibleCallbackRunner : public base::DelegateSimpleThread::Delegate {
  public:
   FlexibleCallbackRunner(base::TimeDelta delay, PipelineStatus status,
-                         const PipelineStatusCB& callback)
+                         const PipelineStatusCB& status_cb)
       : delay_(delay),
         status_(status),
-        callback_(callback) {
+        status_cb_(status_cb) {
     if (delay_ < base::TimeDelta()) {
-      callback_.Run(status_);
+      status_cb_.Run(status_);
       return;
     }
   }
   virtual void Run() {
     if (delay_ < base::TimeDelta()) return;
     base::PlatformThread::Sleep(delay_);
-    callback_.Run(status_);
+    status_cb_.Run(status_);
   }
 
  private:
   base::TimeDelta delay_;
   PipelineStatus status_;
-  PipelineStatusCB callback_;
+  PipelineStatusCB status_cb_;
 };
 
 void TestPipelineStatusNotification(base::TimeDelta delay) {