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());

[Ami GONE FROM CHROMIUM, 2012/09/12 18:45:34]

s/cb/cb_/ (in general, this style makes  it easier to detect accidental
self-assignments in initializer lists)

[acolwell GONE FROM CHROMIUM, 2012/09/12 22:03:53]

Done.

+  DCHECK(!need_key_cb.is_null());

[Ami GONE FROM CHROMIUM, 2012/09/12 18:45:34]

ditto

[acolwell GONE FROM CHROMIUM, 2012/09/12 22:03:53]

Done.

 }
 
 void ChunkDemuxer::Initialize(DemuxerHost* host, const PipelineStatusCB& cb) {
   DVLOG(1) << "Init()";
+  base::Closure open_cb;
   {
     base::AutoLock auto_lock(lock_);
     DCHECK_EQ(state_, WAITING_FOR_INIT);
     host_ = host;
 
     ChangeState_Locked(INITIALIZING);
     init_cb_ = cb;
+
+    std::swap(open_cb, open_cb_);
   }
 
-  client_->DemuxerOpened(this);
+  open_cb.Run();

[Ami GONE FROM CHROMIUM, 2012/09/12 18:45:34]

Is this just good hygiene or is there a reason open_cb_ must be Run() not under
lock?

If need to retain the unlocked nature, does it make sense to instead do:
MessageLoop::current()->PostTask(FROM_HERE, base::ResetAndReturn(&open_cb_));
and drop the extra {}+indent?

[acolwell GONE FROM CHROMIUM, 2012/09/12 22:03:53]

This was intended to be a good hygiene thing and was required by
PipelineIntegrationTest. I updated PipelineIntegrationTest to post to a message
loop like WMPI does. This allows me to call it under lock and deindent like you
suggested.

 }
 
 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 117 matching lines @@
 
   scoped_ptr<StreamParser> stream_parser(factory_function(codecs));
   CHECK(stream_parser.get());
 
   stream_parser->Init(
       base::Bind(&ChunkDemuxer::OnStreamParserInitDone, base::Unretained(this)),
       base::Bind(&ChunkDemuxer::OnNewConfigs, base::Unretained(this),
                  has_audio, has_video),
       audio_cb,
       video_cb,
       base::Bind(&ChunkDemuxer::OnNeedKey, base::Unretained(this)),

[Ami GONE FROM CHROMIUM, 2012/09/12 18:45:34]

possible to just pass need_key_cb_ here and drop OnNeedKey entirely?

[acolwell GONE FROM CHROMIUM, 2012/09/12 22:03:53]

Not yet. There is signature mismatch here that needs to be fixed in a separate
CL. Added a TODO for this.

       base::Bind(&ChunkDemuxer::OnNewMediaSegment, base::Unretained(this), id),
       base::Bind(&ChunkDemuxer::OnEndOfMediaSegment,
                  base::Unretained(this), id));
 
   stream_parser_map_[id] = stream_parser.release();
   SourceInfo info = { base::TimeDelta(), true };
   source_info_map_[id] = info;
 
   return kOk;
 }
@@ skipping 208 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 168 matching lines @@
 
   if (!video_->Append(buffers))
     return false;
 
   IncreaseDurationIfNecessary(buffers, video_);
   return true;
 }
 
 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