Move ChunkDemuxer handling from WMPProxy to WMPI and remove ChunkDemuxerClient

media/filters/chunk_demuxer.cc

 // 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.
 
 #include "media/filters/chunk_demuxer.h"
 
 #include <algorithm>
 #include <deque>
 
 #include "base/bind.h"
 #include "base/callback_helpers.h"
 #include "base/location.h"
 #include "base/logging.h"
 #include "base/message_loop_proxy.h"
 #include "base/string_util.h"
 #include "media/base/audio_decoder_config.h"
 #include "media/base/stream_parser_buffer.h"
 #include "media/base/video_decoder_config.h"
-#include "media/filters/chunk_demuxer_client.h"
 #if defined(GOOGLE_CHROME_BUILD) || defined(USE_PROPRIETARY_CODECS)
 #include "media/mp4/mp4_stream_parser.h"
 #endif
 #include "media/webm/webm_stream_parser.h"
 
 using base::TimeDelta;
 
 namespace media {
 
 struct CodecInfo {
@@ skipping 492 matching lines @@
       DCHECK(read_cbs_.empty());
       *status = DemuxerStream::kOk;
       *buffer = StreamParserBuffer::CreateEOSBuffer();
       return true;
   }
 
   NOTREACHED();
   return false;
 }
 
-ChunkDemuxer::ChunkDemuxer(ChunkDemuxerClient* client)
+ChunkDemuxer::ChunkDemuxer(const base::Closure& open_cb,
+                           const NeedKeyCB& need_key_cb)
     : state_(WAITING_FOR_INIT),
       host_(NULL),
-      client_(client) {
-  DCHECK(client);
+      open_cb_(open_cb),
+      need_key_cb_(need_key_cb) {
+  DCHECK(!open_cb_.is_null());
+  DCHECK(!need_key_cb_.is_null());
 }
 
 void ChunkDemuxer::Initialize(DemuxerHost* host, const PipelineStatusCB& cb) {
   DVLOG(1) << "Init()";
-  {
-    base::AutoLock auto_lock(lock_);
-    DCHECK_EQ(state_, WAITING_FOR_INIT);
-    host_ = host;
 
-    ChangeState_Locked(INITIALIZING);
-    init_cb_ = cb;
-  }
+  base::AutoLock auto_lock(lock_);
+  DCHECK_EQ(state_, WAITING_FOR_INIT);
+  host_ = host;
 
-  client_->DemuxerOpened(this);
+  ChangeState_Locked(INITIALIZING);
+  init_cb_ = cb;
+
+  base::ResetAndReturn(&open_cb_).Run();
 }
 
 void ChunkDemuxer::Stop(const base::Closure& callback) {
   DVLOG(1) << "Stop()";
   Shutdown();
   callback.Run();
 }
 
 void ChunkDemuxer::Seek(TimeDelta time, const PipelineStatusCB& cb) {
   DVLOG(1) << "Seek(" << time.InSecondsF() << ")";
@@ skipping 346 matching lines @@
       audio_->Shutdown();
 
     if (video_)
       video_->Shutdown();
 
     ChangeState_Locked(SHUTDOWN);
   }
 
   if (!cb.is_null())
     cb.Run(PIPELINE_ERROR_ABORT);
-
-  client_->DemuxerClosed();
 }
 
 void ChunkDemuxer::ChangeState_Locked(State new_state) {
   lock_.AssertAcquired();
   DVLOG(1) << "ChunkDemuxer::ChangeState_Locked() : "
            << state_ << " -> " << new_state;
   state_ = new_state;
 }
 
 ChunkDemuxer::~ChunkDemuxer() {
@@ skipping 166 matching lines @@
   AdjustBufferTimestamps(
       buffers, source_info_map_[source_id_video_].timestamp_offset);
 
   if (!video_->Append(buffers))
     return false;
 
   IncreaseDurationIfNecessary(buffers, video_);
   return true;
 }
 
+// TODO(acolwell): Remove bool from StreamParser::NeedKeyCB so that
+// this method can be removed and need_key_cb_ can be passed directly
+// to the parser.
 bool ChunkDemuxer::OnNeedKey(scoped_array<uint8> init_data,
                              int init_data_size) {
-  client_->DemuxerNeedKey(init_data.Pass(), init_data_size);
+  lock_.AssertAcquired();
+  need_key_cb_.Run(init_data.Pass(), init_data_size);
   return true;
 }
 
 void ChunkDemuxer::OnNewMediaSegment(const std::string& source_id,
                                      TimeDelta timestamp) {
   DCHECK(timestamp != kNoTimestamp());
   DVLOG(2) << "OnNewMediaSegment(" << source_id << ", "
            << timestamp.InSecondsF() << ")";
   lock_.AssertAcquired();
 
@@ skipping 66 matching lines @@
 
 Ranges<TimeDelta> ChunkDemuxer::GetBufferedRanges() const {
   if (audio_ && !video_)
     return audio_->GetBufferedRanges(duration_);
   else if (!audio_ && video_)
     return video_->GetBufferedRanges(duration_);
   return ComputeIntersection();
 }
 
 }  // namespace media