Remove media::BindToLoop() in favour of media::BindToCurrentLoop().

content/renderer/media/webmediaplayer_impl.cc

 // Copyright 2013 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 "content/renderer/media/webmediaplayer_impl.h"
 
 #include <algorithm>
 #include <limits>
 #include <string>
 #include <vector>
@@ skipping 99 matching lines @@
 
 #define COMPILE_ASSERT_MATCHING_ENUM(name) \
   COMPILE_ASSERT(static_cast<int>(WebMediaPlayer::CORSMode ## name) == \
                  static_cast<int>(BufferedResourceLoader::k ## name), \
                  mismatching_enums)
 COMPILE_ASSERT_MATCHING_ENUM(Unspecified);
 COMPILE_ASSERT_MATCHING_ENUM(Anonymous);
 COMPILE_ASSERT_MATCHING_ENUM(UseCredentials);
 #undef COMPILE_ASSERT_MATCHING_ENUM
 
-#define BIND_TO_RENDER_LOOP(function) \
-  media::BindToLoop(main_loop_, base::Bind(function, AsWeakPtr()))
-
-#define BIND_TO_RENDER_LOOP_1(function, arg1) \
-  media::BindToLoop(main_loop_, base::Bind(function, AsWeakPtr(), arg1))
-
-#define BIND_TO_RENDER_LOOP_2(function, arg1, arg2) \
-  media::BindToLoop(main_loop_, base::Bind(function, AsWeakPtr(), arg1, arg2))
+#define BIND_TO_CURRENT_LOOP(function) \

[Ami GONE FROM CHROMIUM, 2014/01/08 21:37:41]

"CURRENT" is less informative at the callsite than "RENDER".
WDYT of leaving the macro named BIND_TO_RENDER_LOOP and making the impl of the
macro (here) DCHECK that we're on the main_loop_ before BTCL'ing?

(if you don't take that suggestion, I think you need to do _something_ to avoid
B_T_C_L being an uppercasing+underscoring of BTCL - e.g. incorporate the fact of
the AsWeakPtr into the macro's name)

[scherkus (not reviewing), 2014/01/09 01:52:02]

I really like the DCHECK() idea, but since this macro is typically used inside
param lists, etc.. I had to use a template static helper function.

Let me know what you think.

+  media::BindToCurrentLoop(base::Bind(function, AsWeakPtr()))
 
 static void LogMediaSourceError(const scoped_refptr<media::MediaLog>& media_log,
                                 const std::string& error) {
   media_log->AddEvent(media_log->CreateMediaSourceErrorEvent(error));
 }
 
 WebMediaPlayerImpl::WebMediaPlayerImpl(
     content::RenderView* render_view,
     blink::WebFrame* frame,
     blink::WebMediaPlayerClient* client,
@@ skipping 48 matching lines @@
       FROM_HERE,
       base::Bind(&WebMediaPlayerImpl::IncrementExternallyAllocatedMemory,
                  AsWeakPtr()));
 
   if (blink::WebRuntimeFeatures::isPrefixedEncryptedMediaEnabled()) {
     decryptor_.reset(new ProxyDecryptor(
 #if defined(ENABLE_PEPPER_CDMS)
         client,
         frame,
 #endif
-        BIND_TO_RENDER_LOOP(&WebMediaPlayerImpl::OnKeyAdded),
-        BIND_TO_RENDER_LOOP(&WebMediaPlayerImpl::OnKeyError),
-        BIND_TO_RENDER_LOOP(&WebMediaPlayerImpl::OnKeyMessage)));
+        BIND_TO_CURRENT_LOOP(&WebMediaPlayerImpl::OnKeyAdded),
+        BIND_TO_CURRENT_LOOP(&WebMediaPlayerImpl::OnKeyError),
+        BIND_TO_CURRENT_LOOP(&WebMediaPlayerImpl::OnKeyMessage)));
   }
 
   // Use the null sink if no sink was provided.
   audio_source_provider_ = new WebAudioSourceProviderImpl(
       params.audio_renderer_sink().get()
           ? params.audio_renderer_sink()
           : new media::NullAudioSink(media_loop_));
 }
 
 WebMediaPlayerImpl::~WebMediaPlayerImpl() {
@@ skipping 159 matching lines @@
     paused_time_ = seek_time;
 
   seeking_ = true;
 
   if (chunk_demuxer_)
     chunk_demuxer_->StartWaitingForSeek(seek_time);
 
   // Kick off the asynchronous seek!
   pipeline_->Seek(
       seek_time,
-      BIND_TO_RENDER_LOOP(&WebMediaPlayerImpl::OnPipelineSeek));
+      BIND_TO_CURRENT_LOOP(&WebMediaPlayerImpl::OnPipelineSeek));
 }
 
 void WebMediaPlayerImpl::setRate(double rate) {
   DCHECK(main_loop_->BelongsToCurrentThread());
 
   // TODO(kylep): Remove when support for negatives is added. Also, modify the
   // following checks so rewind uses reasonable values also.
   if (rate < 0.0)
     return;
 
@@ skipping 679 matching lines @@
     SetNetworkState(WebMediaPlayer::NetworkStateIdle);
   else if (is_downloading && network_state_ == WebMediaPlayer::NetworkStateIdle)
     SetNetworkState(WebMediaPlayer::NetworkStateLoading);
   media_log_->AddEvent(
       media_log_->CreateBooleanEvent(
           media::MediaLogEvent::NETWORK_ACTIVITY_SET,
           "is_downloading_data", is_downloading));
 }
 
 void WebMediaPlayerImpl::StartPipeline() {
+  DCHECK(main_loop_->BelongsToCurrentThread());
   const CommandLine* cmd_line = CommandLine::ForCurrentProcess();
 
   // Keep track if this is a MSE or non-MSE playback.
   UMA_HISTOGRAM_BOOLEAN("Media.MSE.Playback",
                         (load_type_ == LoadTypeMediaSource));
 
   // Figure out which demuxer to use.
   if (load_type_ != LoadTypeMediaSource) {
     DCHECK(!chunk_demuxer_);
     DCHECK(data_source_);
 
     demuxer_.reset(new media::FFmpegDemuxer(
         media_loop_, data_source_.get(),
-        BIND_TO_RENDER_LOOP(&WebMediaPlayerImpl::OnNeedKey),
+        BIND_TO_CURRENT_LOOP(&WebMediaPlayerImpl::OnNeedKey),
         media_log_));
   } else {
     DCHECK(!chunk_demuxer_);
     DCHECK(!data_source_);
 
     chunk_demuxer_ = new media::ChunkDemuxer(
-        BIND_TO_RENDER_LOOP(&WebMediaPlayerImpl::OnDemuxerOpened),
-        BIND_TO_RENDER_LOOP(&WebMediaPlayerImpl::OnNeedKey),
+        BIND_TO_CURRENT_LOOP(&WebMediaPlayerImpl::OnDemuxerOpened),
+        BIND_TO_CURRENT_LOOP(&WebMediaPlayerImpl::OnNeedKey),
         base::Bind(&LogMediaSourceError, media_log_));
     demuxer_.reset(chunk_demuxer_);
   }
 
   scoped_ptr<media::FilterCollection> filter_collection(
       new media::FilterCollection());
   filter_collection->SetDemuxer(demuxer_.get());
 
   // Figure out if EME is enabled.
   media::SetDecryptorReadyCB set_decryptor_ready_cb;
@@ skipping 29 matching lines @@
 #endif  // !defined(MEDIA_DISABLE_LIBVPX)
 
   video_decoders.push_back(new media::FFmpegVideoDecoder(media_loop_));
 
   scoped_ptr<media::VideoRenderer> video_renderer(
       new media::VideoRendererImpl(
           media_loop_,
           video_decoders.Pass(),
           set_decryptor_ready_cb,
           base::Bind(&WebMediaPlayerImpl::FrameReady, base::Unretained(this)),
-          BIND_TO_RENDER_LOOP(&WebMediaPlayerImpl::SetOpaque),
+          BIND_TO_CURRENT_LOOP(&WebMediaPlayerImpl::SetOpaque),
           true));
   filter_collection->SetVideoRenderer(video_renderer.Pass());
 
   if (cmd_line->HasSwitch(switches::kEnableInbandTextTracks)) {
     scoped_ptr<media::TextRenderer> text_renderer(
         new media::TextRenderer(
             media_loop_,
-            BIND_TO_RENDER_LOOP(&WebMediaPlayerImpl::OnAddTextTrack)));
+            BIND_TO_CURRENT_LOOP(&WebMediaPlayerImpl::OnAddTextTrack)));
 
     filter_collection->SetTextRenderer(text_renderer.Pass());
   }
 
   // ... and we're ready to go!
   starting_ = true;
   pipeline_->Start(
       filter_collection.Pass(),
-      BIND_TO_RENDER_LOOP(&WebMediaPlayerImpl::OnPipelineEnded),
-      BIND_TO_RENDER_LOOP(&WebMediaPlayerImpl::OnPipelineError),
-      BIND_TO_RENDER_LOOP(&WebMediaPlayerImpl::OnPipelineSeek),
-      BIND_TO_RENDER_LOOP(&WebMediaPlayerImpl::OnPipelineBufferingState),
-      BIND_TO_RENDER_LOOP(&WebMediaPlayerImpl::OnDurationChange));
+      BIND_TO_CURRENT_LOOP(&WebMediaPlayerImpl::OnPipelineEnded),
+      BIND_TO_CURRENT_LOOP(&WebMediaPlayerImpl::OnPipelineError),
+      BIND_TO_CURRENT_LOOP(&WebMediaPlayerImpl::OnPipelineSeek),
+      BIND_TO_CURRENT_LOOP(&WebMediaPlayerImpl::OnPipelineBufferingState),
+      BIND_TO_CURRENT_LOOP(&WebMediaPlayerImpl::OnDurationChange));
 }
 
 void WebMediaPlayerImpl::SetNetworkState(WebMediaPlayer::NetworkState state) {
   DCHECK(main_loop_->BelongsToCurrentThread());
   DVLOG(1) << "SetNetworkState: " << state;
   network_state_ = state;
   // Always notify to ensure client has the latest value.
   client_->networkStateChanged();
 }
 
@@ skipping 121 matching lines @@
   // The |current_frame_| wasn't painted, it is being replaced, and we haven't
   // even gotten the chance to request a repaint for it yet. Mark it as dropped.
   TRACE_EVENT0("media", "WebMediaPlayerImpl:frameDropped");
   DVLOG(1) << "Frame dropped before being painted: "
            << current_frame_->GetTimestamp().InSecondsF();
   if (frames_dropped_before_paint_ < kuint32max)
     frames_dropped_before_paint_++;
 }
 
 }  // namespace content