Use base::MessageLoopProxy instead of MessageLoop* in webkit/media/.

webkit/media/webmediaplayer_impl.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 "webkit/media/webmediaplayer_impl.h"
 
 #include <algorithm>
 #include <limits>
 #include <string>
 #include <vector>
@@ skipping 78 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_->message_loop_proxy(), base::Bind( \
-      function, AsWeakPtr()))
+  media::BindToLoop(main_loop_, base::Bind(function, AsWeakPtr()))
 
 #define BIND_TO_RENDER_LOOP_2(function, arg1, arg2) \
-  media::BindToLoop(main_loop_->message_loop_proxy(), base::Bind( \
-      function, AsWeakPtr(), arg1, arg2))
+  media::BindToLoop(main_loop_, base::Bind(function, AsWeakPtr(), arg1, arg2))
 
 static WebKit::WebTimeRanges ConvertToWebTimeRanges(
     const media::Ranges<base::TimeDelta>& ranges) {
   WebKit::WebTimeRanges result(ranges.size());
   for (size_t i = 0; i < ranges.size(); i++) {
     result[i].start = ranges.start(i).InSecondsF();
     result[i].end = ranges.end(i).InSecondsF();
   }
   return result;
 }
 
 static void LogMediaSourceError(const scoped_refptr<media::MediaLog>& media_log,
                                 const std::string& error) {
   media_log->AddEvent(media_log->CreateMediaSourceErrorEvent(error));
 }
 
 WebMediaPlayerImpl::WebMediaPlayerImpl(
     WebKit::WebFrame* frame,
     WebKit::WebMediaPlayerClient* client,
     base::WeakPtr<WebMediaPlayerDelegate> delegate,
     const WebMediaPlayerParams& params)
     : frame_(frame),
       network_state_(WebMediaPlayer::NetworkStateEmpty),
       ready_state_(WebMediaPlayer::ReadyStateHaveNothing),
-      main_loop_(MessageLoop::current()),
+      main_loop_(base::MessageLoopProxy::current()),
       filter_collection_(new media::FilterCollection()),
       media_thread_("MediaPipeline"),
       paused_(true),
       seeking_(false),
       playback_rate_(0.0f),
       pending_seek_(false),
       pending_seek_seconds_(0.0f),
       client_(client),
-      proxy_(new WebMediaPlayerProxy(main_loop_->message_loop_proxy(), this)),
+      proxy_(new WebMediaPlayerProxy(main_loop_, this)),
       delegate_(delegate),
       media_stream_client_(params.media_stream_client()),
       media_log_(params.media_log()),
       accelerated_compositing_reported_(false),
       incremented_externally_allocated_memory_(false),
       is_local_source_(false),
       supports_save_(true),
       starting_(false) {
   media_log_->AddEvent(
       media_log_->CreateEvent(media::MediaLogEvent::WEBMEDIAPLAYER_CREATED));
 
   CHECK(media_thread_.Start());
   pipeline_ = new media::Pipeline(
       media_thread_.message_loop_proxy(), media_log_);
 
   // Let V8 know we started new thread if we did not do it yet.
   // Made separate task to avoid deletion of player currently being created.
   // Also, delaying GC until after player starts gets rid of starting lag --
   // collection happens in parallel with playing.
   //
   // TODO(enal): remove when we get rid of per-audio-stream thread.
-  MessageLoop::current()->PostTask(
+  main_loop_->PostTask(
       FROM_HERE,
       base::Bind(&WebMediaPlayerImpl::IncrementExternallyAllocatedMemory,
                  AsWeakPtr()));
 
   // Also we want to be notified of |main_loop_| destruction.
-  main_loop_->AddDestructionObserver(this);
+  MessageLoop::current()->AddDestructionObserver(this);
 
   media::SetDecryptorReadyCB set_decryptor_ready_cb;
   if (WebKit::WebRuntimeFeatures::isEncryptedMediaEnabled()) {
     decryptor_.reset(new ProxyDecryptor(
         client,
         frame,
         BIND_TO_RENDER_LOOP(&WebMediaPlayerImpl::OnKeyAdded),
         BIND_TO_RENDER_LOOP(&WebMediaPlayerImpl::OnKeyError),
         BIND_TO_RENDER_LOOP(&WebMediaPlayerImpl::OnKeyMessage),
         BIND_TO_RENDER_LOOP(&WebMediaPlayerImpl::OnNeedKey)));
@@ skipping 25 matching lines @@
       new media::NullAudioSink());
   scoped_ptr<media::AudioRenderer> audio_renderer(
       new media::AudioRendererImpl(
         media_thread_.message_loop_proxy(),
         audio_source_provider_,
         set_decryptor_ready_cb));
   filter_collection_->SetAudioRenderer(audio_renderer.Pass());
 }
 
 WebMediaPlayerImpl::~WebMediaPlayerImpl() {
-  DCHECK_EQ(main_loop_, MessageLoop::current());
+  DCHECK(main_loop_->BelongsToCurrentThread());
   Destroy();
   media_log_->AddEvent(
       media_log_->CreateEvent(media::MediaLogEvent::WEBMEDIAPLAYER_DESTROYED));
 
   if (delegate_)
     delegate_->PlayerGone(this);
 
-  // Finally tell the |main_loop_| we don't want to be notified of destruction
-  // event.
-  if (main_loop_) {
-    main_loop_->RemoveDestructionObserver(this);
-  }
+  // Remove destruction observer if we're being destroyed but the main thread is
+  // still running.
+  if (MessageLoop::current())
+    MessageLoop::current()->RemoveDestructionObserver(this);
 }
 
 namespace {
 
 // Helper enum for reporting scheme histograms.
 enum URLSchemeForHistogram {
   kUnknownURLScheme,
   kMissingURLScheme,
   kHttpURLScheme,
   kHttpsURLScheme,
@@ skipping 17 matching lines @@
   if (url.SchemeIs("file")) return kFileURLScheme;
   if (url.SchemeIs("blob")) return kBlobURLScheme;
   if (url.SchemeIs("data")) return kDataURLScheme;
   if (url.SchemeIs("filesystem")) return kFileSystemScheme;
   return kUnknownURLScheme;
 }
 
 }  // anonymous namespace
 
 void WebMediaPlayerImpl::load(const WebKit::WebURL& url, CORSMode cors_mode) {
-  DCHECK_EQ(main_loop_, MessageLoop::current());
+  DCHECK(main_loop_->BelongsToCurrentThread());
 
   GURL gurl(url);
   UMA_HISTOGRAM_ENUMERATION("Media.URLScheme", URLScheme(gurl), kMaxURLScheme);
 
   // Handle any volume/preload changes that occured before load().
   setVolume(GetClient()->volume());
   setPreload(GetClient()->preload());
 
   SetNetworkState(WebMediaPlayer::NetworkStateLoading);
   SetReadyState(WebMediaPlayer::ReadyStateHaveNothing);
@@ skipping 35 matching lines @@
           AsWeakPtr(), gurl));
 
   is_local_source_ = !gurl.SchemeIs("http") && !gurl.SchemeIs("https");
 
   BuildDefaultCollection(proxy_->data_source(),
                          media_thread_.message_loop_proxy(),
                          filter_collection_.get());
 }
 
 void WebMediaPlayerImpl::cancelLoad() {
-  DCHECK_EQ(main_loop_, MessageLoop::current());
+  DCHECK(main_loop_->BelongsToCurrentThread());
 }
 
 void WebMediaPlayerImpl::play() {
-  DCHECK_EQ(main_loop_, MessageLoop::current());
+  DCHECK(main_loop_->BelongsToCurrentThread());
 
   paused_ = false;
   pipeline_->SetPlaybackRate(playback_rate_);
 
   media_log_->AddEvent(media_log_->CreateEvent(media::MediaLogEvent::PLAY));
 
   if (delegate_)
     delegate_->DidPlay(this);
 }
 
 void WebMediaPlayerImpl::pause() {
-  DCHECK_EQ(main_loop_, MessageLoop::current());
+  DCHECK(main_loop_->BelongsToCurrentThread());
 
   paused_ = true;
   pipeline_->SetPlaybackRate(0.0f);
   paused_time_ = pipeline_->GetMediaTime();
 
   media_log_->AddEvent(media_log_->CreateEvent(media::MediaLogEvent::PAUSE));
 
   if (delegate_)
     delegate_->DidPause(this);
 }
 
 bool WebMediaPlayerImpl::supportsFullscreen() const {
-  DCHECK_EQ(main_loop_, MessageLoop::current());
+  DCHECK(main_loop_->BelongsToCurrentThread());
   return true;
 }
 
 bool WebMediaPlayerImpl::supportsSave() const {
-  DCHECK_EQ(main_loop_, MessageLoop::current());
+  DCHECK(main_loop_->BelongsToCurrentThread());
   return supports_save_;
 }
 
 void WebMediaPlayerImpl::seek(float seconds) {
-  DCHECK_EQ(main_loop_, MessageLoop::current());
+  DCHECK(main_loop_->BelongsToCurrentThread());
 
   if (starting_ || seeking_) {
     pending_seek_ = true;
     pending_seek_seconds_ = seconds;
     if (chunk_demuxer_)
       chunk_demuxer_->CancelPendingSeek();
     return;
   }
 
   media_log_->AddEvent(media_log_->CreateSeekEvent(seconds));
 
   base::TimeDelta seek_time = ConvertSecondsToTimestamp(seconds);
 
   // Update our paused time.
   if (paused_)
     paused_time_ = seek_time;
 
   seeking_ = true;
 
   if (chunk_demuxer_)
     chunk_demuxer_->StartWaitingForSeek();
 
   // Kick off the asynchronous seek!
   pipeline_->Seek(
       seek_time,
       BIND_TO_RENDER_LOOP(&WebMediaPlayerImpl::OnPipelineSeek));
 }
 
 void WebMediaPlayerImpl::setEndTime(float seconds) {
-  DCHECK_EQ(main_loop_, MessageLoop::current());
+  DCHECK(main_loop_->BelongsToCurrentThread());
 
   // TODO(hclam): add method call when it has been implemented.
   return;
 }
 
 void WebMediaPlayerImpl::setRate(float rate) {
-  DCHECK_EQ(main_loop_, MessageLoop::current());
+  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.0f)
     return;
 
   // Limit rates to reasonable values by clamping.
   if (rate != 0.0f) {
     if (rate < kMinRate)
       rate = kMinRate;
     else if (rate > kMaxRate)
       rate = kMaxRate;
   }
 
   playback_rate_ = rate;
   if (!paused_) {
     pipeline_->SetPlaybackRate(rate);
   }
 }
 
 void WebMediaPlayerImpl::setVolume(float volume) {
-  DCHECK_EQ(main_loop_, MessageLoop::current());
+  DCHECK(main_loop_->BelongsToCurrentThread());
 
   pipeline_->SetVolume(volume);
 }
 
 void WebMediaPlayerImpl::setVisible(bool visible) {
-  DCHECK_EQ(main_loop_, MessageLoop::current());
+  DCHECK(main_loop_->BelongsToCurrentThread());
 
   // TODO(hclam): add appropriate method call when pipeline has it implemented.
   return;
 }
 
 #define COMPILE_ASSERT_MATCHING_ENUM(webkit_name, chromium_name) \
     COMPILE_ASSERT(static_cast<int>(WebMediaPlayer::webkit_name) == \
                    static_cast<int>(webkit_media::chromium_name), \
                    mismatching_enums)
 COMPILE_ASSERT_MATCHING_ENUM(PreloadNone, NONE);
 COMPILE_ASSERT_MATCHING_ENUM(PreloadMetaData, METADATA);
 COMPILE_ASSERT_MATCHING_ENUM(PreloadAuto, AUTO);
 #undef COMPILE_ASSERT_MATCHING_ENUM
 
 void WebMediaPlayerImpl::setPreload(WebMediaPlayer::Preload preload) {
-  DCHECK_EQ(main_loop_, MessageLoop::current());
+  DCHECK(main_loop_->BelongsToCurrentThread());
 
   if (proxy_ && proxy_->data_source()) {
     // XXX: Why do I need to use webkit_media:: prefix? clang complains!
     proxy_->data_source()->SetPreload(
         static_cast<webkit_media::Preload>(preload));
   }
 }
 
 bool WebMediaPlayerImpl::totalBytesKnown() {
-  DCHECK_EQ(main_loop_, MessageLoop::current());
+  DCHECK(main_loop_->BelongsToCurrentThread());
 
   return pipeline_->GetTotalBytes() != 0;
 }
 
 bool WebMediaPlayerImpl::hasVideo() const {
-  DCHECK_EQ(main_loop_, MessageLoop::current());
+  DCHECK(main_loop_->BelongsToCurrentThread());
 
   return pipeline_->HasVideo();
 }
 
 bool WebMediaPlayerImpl::hasAudio() const {
-  DCHECK_EQ(main_loop_, MessageLoop::current());
+  DCHECK(main_loop_->BelongsToCurrentThread());
 
   return pipeline_->HasAudio();
 }
 
 WebKit::WebSize WebMediaPlayerImpl::naturalSize() const {
-  DCHECK_EQ(main_loop_, MessageLoop::current());
+  DCHECK(main_loop_->BelongsToCurrentThread());
 
   gfx::Size size;
   pipeline_->GetNaturalVideoSize(&size);
   return WebKit::WebSize(size);
 }
 
 bool WebMediaPlayerImpl::paused() const {
-  DCHECK_EQ(main_loop_, MessageLoop::current());
+  DCHECK(main_loop_->BelongsToCurrentThread());
 
   return pipeline_->GetPlaybackRate() == 0.0f;
 }
 
 bool WebMediaPlayerImpl::seeking() const {
-  DCHECK_EQ(main_loop_, MessageLoop::current());
+  DCHECK(main_loop_->BelongsToCurrentThread());
 
   if (ready_state_ == WebMediaPlayer::ReadyStateHaveNothing)
     return false;
 
   return seeking_;
 }
 
 float WebMediaPlayerImpl::duration() const {
-  DCHECK_EQ(main_loop_, MessageLoop::current());
+  DCHECK(main_loop_->BelongsToCurrentThread());
 
   if (ready_state_ == WebMediaPlayer::ReadyStateHaveNothing)
     return std::numeric_limits<float>::quiet_NaN();
 
   double duration;
   if (chunk_demuxer_) {
     duration = chunk_demuxer_->GetDuration();
   } else {
     duration = GetPipelineDuration();
   }
 
   // Make sure super small durations don't get truncated to 0 and
   // large durations don't get converted to infinity by the double -> float
   // conversion.
   //
   // TODO(acolwell): Remove when WebKit is changed to report duration as a
   // double.
   if (duration > 0.0 && duration < std::numeric_limits<double>::infinity()) {
     duration = std::max(duration,
                         static_cast<double>(std::numeric_limits<float>::min()));
     duration = std::min(duration,
                         static_cast<double>(std::numeric_limits<float>::max()));
   }
 
   return static_cast<float>(duration);
 }
 
 float WebMediaPlayerImpl::currentTime() const {
-  DCHECK_EQ(main_loop_, MessageLoop::current());
+  DCHECK(main_loop_->BelongsToCurrentThread());
   if (paused_)
     return static_cast<float>(paused_time_.InSecondsF());
   return static_cast<float>(pipeline_->GetMediaTime().InSecondsF());
 }
 
 int WebMediaPlayerImpl::dataRate() const {
-  DCHECK_EQ(main_loop_, MessageLoop::current());
+  DCHECK(main_loop_->BelongsToCurrentThread());
 
   // TODO(hclam): Add this method call if pipeline has it in the interface.
   return 0;
 }
 
 WebMediaPlayer::NetworkState WebMediaPlayerImpl::networkState() const {
-  DCHECK_EQ(main_loop_, MessageLoop::current());
+  DCHECK(main_loop_->BelongsToCurrentThread());
   return network_state_;
 }
 
 WebMediaPlayer::ReadyState WebMediaPlayerImpl::readyState() const {
-  DCHECK_EQ(main_loop_, MessageLoop::current());
+  DCHECK(main_loop_->BelongsToCurrentThread());
   return ready_state_;
 }
 
 const WebKit::WebTimeRanges& WebMediaPlayerImpl::buffered() {
-  DCHECK_EQ(main_loop_, MessageLoop::current());
+  DCHECK(main_loop_->BelongsToCurrentThread());
   WebKit::WebTimeRanges web_ranges(
       ConvertToWebTimeRanges(pipeline_->GetBufferedTimeRanges()));
   buffered_.swap(web_ranges);
   return buffered_;
 }
 
 float WebMediaPlayerImpl::maxTimeSeekable() const {
-  DCHECK_EQ(main_loop_, MessageLoop::current());
+  DCHECK(main_loop_->BelongsToCurrentThread());
 
   // If we haven't even gotten to ReadyStateHaveMetadata yet then just
   // return 0 so that the seekable range is empty.
   if (ready_state_ < WebMediaPlayer::ReadyStateHaveMetadata)
     return 0.0f;
 
   // We don't support seeking in streaming media.
   if (proxy_ && proxy_->data_source() && proxy_->data_source()->IsStreaming())
     return 0.0f;
   return duration();
 }
 
 bool WebMediaPlayerImpl::didLoadingProgress() const {
-  DCHECK_EQ(main_loop_, MessageLoop::current());
+  DCHECK(main_loop_->BelongsToCurrentThread());
   return pipeline_->DidLoadingProgress();
 }
 
 unsigned long long WebMediaPlayerImpl::totalBytes() const {
-  DCHECK_EQ(main_loop_, MessageLoop::current());
+  DCHECK(main_loop_->BelongsToCurrentThread());
 
   return pipeline_->GetTotalBytes();
 }
 
 void WebMediaPlayerImpl::setSize(const WebSize& size) {
-  DCHECK_EQ(main_loop_, MessageLoop::current());
+  DCHECK(main_loop_->BelongsToCurrentThread());
 
   // Don't need to do anything as we use the dimensions passed in via paint().
 }
 
 void WebMediaPlayerImpl::paint(WebCanvas* canvas,
                                const WebRect& rect,
                                uint8_t alpha) {
-  DCHECK_EQ(main_loop_, MessageLoop::current());
+  DCHECK(main_loop_->BelongsToCurrentThread());
   DCHECK(proxy_);
 
   if (!accelerated_compositing_reported_) {
     accelerated_compositing_reported_ = true;
     // Normally paint() is only called in non-accelerated rendering, but there
     // are exceptions such as webgl where compositing is used in the WebView but
     // video frames are still rendered to a canvas.
     UMA_HISTOGRAM_BOOLEAN(
         "Media.AcceleratedCompositingActive",
         frame_->view()->isAcceleratedCompositingActive());
   }
 
   proxy_->Paint(canvas, rect, alpha);
 }
 
 bool WebMediaPlayerImpl::hasSingleSecurityOrigin() const {
   if (proxy_)
     return proxy_->HasSingleOrigin();
   return true;
 }
 
 bool WebMediaPlayerImpl::didPassCORSAccessCheck() const {
   return proxy_ && proxy_->DidPassCORSAccessCheck();
 }
 
 WebMediaPlayer::MovieLoadType WebMediaPlayerImpl::movieLoadType() const {
-  DCHECK_EQ(main_loop_, MessageLoop::current());
+  DCHECK(main_loop_->BelongsToCurrentThread());
 
   // Disable seeking while streaming.
   if (proxy_ && proxy_->data_source() && proxy_->data_source()->IsStreaming())
     return WebMediaPlayer::MovieLoadTypeLiveStream;
   return WebMediaPlayer::MovieLoadTypeUnknown;
 }
 
 float WebMediaPlayerImpl::mediaTimeForTimeValue(float timeValue) const {
   return ConvertSecondsToTimestamp(timeValue).InSecondsF();
 }
 
 unsigned WebMediaPlayerImpl::decodedFrameCount() const {
-  DCHECK_EQ(main_loop_, MessageLoop::current());
+  DCHECK(main_loop_->BelongsToCurrentThread());
 
   media::PipelineStatistics stats = pipeline_->GetStatistics();
   return stats.video_frames_decoded;
 }
 
 unsigned WebMediaPlayerImpl::droppedFrameCount() const {
-  DCHECK_EQ(main_loop_, MessageLoop::current());
+  DCHECK(main_loop_->BelongsToCurrentThread());
 
   media::PipelineStatistics stats = pipeline_->GetStatistics();
   return stats.video_frames_dropped;
 }
 
 unsigned WebMediaPlayerImpl::audioDecodedByteCount() const {
-  DCHECK_EQ(main_loop_, MessageLoop::current());
+  DCHECK(main_loop_->BelongsToCurrentThread());
 
   media::PipelineStatistics stats = pipeline_->GetStatistics();
   return stats.audio_bytes_decoded;
 }
 
 unsigned WebMediaPlayerImpl::videoDecodedByteCount() const {
-  DCHECK_EQ(main_loop_, MessageLoop::current());
+  DCHECK(main_loop_->BelongsToCurrentThread());
 
   media::PipelineStatistics stats = pipeline_->GetStatistics();
   return stats.video_bytes_decoded;
 }
 
 WebKit::WebVideoFrame* WebMediaPlayerImpl::getCurrentFrame() {
   scoped_refptr<media::VideoFrame> video_frame;
   proxy_->GetCurrentFrame(&video_frame);
   if (video_frame.get())
     return new WebVideoFrameImpl(video_frame);
@@ skipping 16 matching lines @@
                    mismatching_status_enums)
 COMPILE_ASSERT_MATCHING_STATUS_ENUM(AddIdStatusOk, kOk);
 COMPILE_ASSERT_MATCHING_STATUS_ENUM(AddIdStatusNotSupported, kNotSupported);
 COMPILE_ASSERT_MATCHING_STATUS_ENUM(AddIdStatusReachedIdLimit, kReachedIdLimit);
 #undef COMPILE_ASSERT_MATCHING_ENUM
 
 WebMediaPlayer::AddIdStatus WebMediaPlayerImpl::sourceAddId(
     const WebKit::WebString& id,
     const WebKit::WebString& type,
     const WebKit::WebVector<WebKit::WebString>& codecs) {
-  DCHECK_EQ(main_loop_, MessageLoop::current());
+  DCHECK(main_loop_->BelongsToCurrentThread());
   std::vector<std::string> new_codecs(codecs.size());
   for (size_t i = 0; i < codecs.size(); ++i)
     new_codecs[i] = codecs[i].utf8().data();
 
   return static_cast<WebMediaPlayer::AddIdStatus>(
       chunk_demuxer_->AddId(id.utf8().data(), type.utf8().data(), new_codecs));
 }
 
 bool WebMediaPlayerImpl::sourceRemoveId(const WebKit::WebString& id) {
   DCHECK(!id.isEmpty());
   chunk_demuxer_->RemoveId(id.utf8().data());
   return true;
 }
 
 WebKit::WebTimeRanges WebMediaPlayerImpl::sourceBuffered(
     const WebKit::WebString& id) {
   return ConvertToWebTimeRanges(
       chunk_demuxer_->GetBufferedRanges(id.utf8().data()));
 }
 
 bool WebMediaPlayerImpl::sourceAppend(const WebKit::WebString& id,
                                       const unsigned char* data,
                                       unsigned length) {
-  DCHECK_EQ(main_loop_, MessageLoop::current());
+  DCHECK(main_loop_->BelongsToCurrentThread());
 
   if (!chunk_demuxer_->AppendData(id.utf8().data(), data, length))
     return false;
 
   return true;
 }
 
 bool WebMediaPlayerImpl::sourceAbort(const WebKit::WebString& id) {
   chunk_demuxer_->Abort(id.utf8().data());
   return true;
 }
 
 void WebMediaPlayerImpl::sourceSetDuration(double new_duration) {
   DCHECK_GE(new_duration, 0);
   chunk_demuxer_->SetDuration(new_duration);
 }
 
 void WebMediaPlayerImpl::sourceEndOfStream(
     WebMediaPlayer::EndOfStreamStatus status) {
-  DCHECK_EQ(main_loop_, MessageLoop::current());
+  DCHECK(main_loop_->BelongsToCurrentThread());
   media::PipelineStatus pipeline_status = media::PIPELINE_OK;
 
   switch (status) {
     case WebMediaPlayer::EndOfStreamStatusNoError:
       break;
     case WebMediaPlayer::EndOfStreamStatusNetworkError:
       pipeline_status = media::PIPELINE_ERROR_NETWORK;
       break;
     case WebMediaPlayer::EndOfStreamStatusDecodeError:
       pipeline_status = media::PIPELINE_ERROR_DECODE;
@@ skipping 151 matching lines @@
 
   if (current_key_system_.isEmpty() || key_system != current_key_system_)
     return WebMediaPlayer::MediaKeyExceptionInvalidPlayerState;
 
   decryptor_->CancelKeyRequest(key_system.utf8(), session_id.utf8());
   return WebMediaPlayer::MediaKeyExceptionNoError;
 }
 
 void WebMediaPlayerImpl::WillDestroyCurrentMessageLoop() {
   Destroy();
-  main_loop_ = NULL;
 }
 
 void WebMediaPlayerImpl::Repaint() {
-  DCHECK_EQ(main_loop_, MessageLoop::current());
+  DCHECK(main_loop_->BelongsToCurrentThread());
   GetClient()->repaint();
 }
 
 void WebMediaPlayerImpl::OnPipelineSeek(PipelineStatus status) {
-  DCHECK_EQ(main_loop_, MessageLoop::current());
+  DCHECK(main_loop_->BelongsToCurrentThread());
   starting_ = false;
   seeking_ = false;
   if (pending_seek_) {
     pending_seek_ = false;
     seek(pending_seek_seconds_);
     return;
   }
 
   if (status != media::PIPELINE_OK) {
     OnPipelineError(status);
     return;
   }
 
   // Update our paused time.
   if (paused_)
     paused_time_ = pipeline_->GetMediaTime();
 
   GetClient()->timeChanged();
 }
 
 void WebMediaPlayerImpl::OnPipelineEnded() {
-  DCHECK_EQ(main_loop_, MessageLoop::current());
+  DCHECK(main_loop_->BelongsToCurrentThread());
   GetClient()->timeChanged();
 }
 
 void WebMediaPlayerImpl::OnPipelineError(PipelineStatus error) {
-  DCHECK_EQ(main_loop_, MessageLoop::current());
+  DCHECK(main_loop_->BelongsToCurrentThread());
 
   if (ready_state_ == WebMediaPlayer::ReadyStateHaveNothing) {
     // Any error that occurs before reaching ReadyStateHaveMetadata should
     // be considered a format error.
     SetNetworkState(WebMediaPlayer::NetworkStateFormatError);
     Repaint();
     return;
   }
 
   switch (error) {
@@ skipping 58 matching lines @@
     case media::Pipeline::kPrerollCompleted:
       SetReadyState(WebMediaPlayer::ReadyStateHaveEnoughData);
       break;
   }
 
   // Repaint to trigger UI update.
   Repaint();
 }
 
 void WebMediaPlayerImpl::OnDemuxerOpened() {
-  DCHECK_EQ(main_loop_, MessageLoop::current());
+  DCHECK(main_loop_->BelongsToCurrentThread());
   GetClient()->sourceOpened();
 }
 
 void WebMediaPlayerImpl::OnKeyAdded(const std::string& key_system,
                                     const std::string& session_id) {
-  DCHECK_EQ(main_loop_, MessageLoop::current());
+  DCHECK(main_loop_->BelongsToCurrentThread());
 
   base::Histogram::FactoryGet(
       kMediaEme + KeySystemNameForUMA(key_system) + ".KeyAdded",
       1, 1000000, 50,
       base::Histogram::kUmaTargetedHistogramFlag)->Add(1);
 
   GetClient()->keyAdded(WebString::fromUTF8(key_system),
                         WebString::fromUTF8(session_id));
 }
 
 void WebMediaPlayerImpl::OnNeedKey(const std::string& key_system,
                                    const std::string& session_id,
                                    const std::string& type,
                                    scoped_array<uint8> init_data,
                                    int init_data_size) {
-  DCHECK_EQ(main_loop_, MessageLoop::current());
+  DCHECK(main_loop_->BelongsToCurrentThread());
 
   // Do not fire NeedKey event if encrypted media is not enabled.
   if (!decryptor_)
     return;
 
   UMA_HISTOGRAM_COUNTS(kMediaEme + std::string("NeedKey"), 1);
 
   DCHECK(init_data_type_.empty() || type.empty() || type == init_data_type_);
   if (init_data_type_.empty())
     init_data_type_ = type;
@@ skipping 13 matching lines @@
 COMPILE_ASSERT_MATCHING_ENUM(ServiceError);
 COMPILE_ASSERT_MATCHING_ENUM(OutputError);
 COMPILE_ASSERT_MATCHING_ENUM(HardwareChangeError);
 COMPILE_ASSERT_MATCHING_ENUM(DomainError);
 #undef COMPILE_ASSERT_MATCHING_ENUM
 
 void WebMediaPlayerImpl::OnKeyError(const std::string& key_system,
                                     const std::string& session_id,
                                     media::Decryptor::KeyError error_code,
                                     int system_code) {
-  DCHECK_EQ(main_loop_, MessageLoop::current());
+  DCHECK(main_loop_->BelongsToCurrentThread());
 
   base::LinearHistogram::FactoryGet(
       kMediaEme + KeySystemNameForUMA(key_system) + ".KeyError", 1,
       media::Decryptor::kMaxKeyError, media::Decryptor::kMaxKeyError + 1,
       base::Histogram::kUmaTargetedHistogramFlag)->Add(error_code);
 
   GetClient()->keyError(
       WebString::fromUTF8(key_system),
       WebString::fromUTF8(session_id),
       static_cast<WebKit::WebMediaPlayerClient::MediaKeyErrorCode>(error_code),
       system_code);
 }
 
 void WebMediaPlayerImpl::OnKeyMessage(const std::string& key_system,
                                       const std::string& session_id,
                                       const std::string& message,
                                       const std::string& default_url) {
-  DCHECK_EQ(main_loop_, MessageLoop::current());
+  DCHECK(main_loop_->BelongsToCurrentThread());
 
   const GURL default_url_gurl(default_url);
   DLOG_IF(WARNING, !default_url.empty() && !default_url_gurl.is_valid())
       << "Invalid URL in default_url: " << default_url;
 
   GetClient()->keyMessage(WebString::fromUTF8(key_system),
                           WebString::fromUTF8(session_id),
                           reinterpret_cast<const uint8*>(message.data()),
                           message.size(),
                           default_url_gurl);
 }
 
 void WebMediaPlayerImpl::SetOpaque(bool opaque) {
-  DCHECK_EQ(main_loop_, MessageLoop::current());
+  DCHECK(main_loop_->BelongsToCurrentThread());
 
   GetClient()->setOpaque(opaque);
 }
 
 void WebMediaPlayerImpl::DataSourceInitialized(const GURL& gurl, bool success) {
-  DCHECK_EQ(main_loop_, MessageLoop::current());
+  DCHECK(main_loop_->BelongsToCurrentThread());
 
   if (!success) {
     SetNetworkState(WebMediaPlayer::NetworkStateFormatError);
     Repaint();
     return;
   }
 
   StartPipeline();
 }
 
@@ skipping 13 matching lines @@
   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));
 }
 
 void WebMediaPlayerImpl::SetNetworkState(WebMediaPlayer::NetworkState state) {
-  DCHECK_EQ(main_loop_, MessageLoop::current());
+  DCHECK(main_loop_->BelongsToCurrentThread());
   DVLOG(1) << "SetNetworkState: " << state;
   network_state_ = state;
   // Always notify to ensure client has the latest value.
   GetClient()->networkStateChanged();
 }
 
 void WebMediaPlayerImpl::SetReadyState(WebMediaPlayer::ReadyState state) {
-  DCHECK_EQ(main_loop_, MessageLoop::current());
+  DCHECK(main_loop_->BelongsToCurrentThread());
   DVLOG(1) << "SetReadyState: " << state;
 
   if (ready_state_ == WebMediaPlayer::ReadyStateHaveNothing &&
       state >= WebMediaPlayer::ReadyStateHaveMetadata) {
     if (!hasVideo())
       GetClient()->disableAcceleratedCompositing();
   } else if (state == WebMediaPlayer::ReadyStateHaveEnoughData) {
     if (is_local_source_ &&
         network_state_ == WebMediaPlayer::NetworkStateLoading) {
       SetNetworkState(WebMediaPlayer::NetworkStateLoaded);
     }
   }
 
   ready_state_ = state;
   // Always notify to ensure client has the latest value.
   GetClient()->readyStateChanged();
 }
 
 void WebMediaPlayerImpl::Destroy() {
-  DCHECK_EQ(main_loop_, MessageLoop::current());
+  DCHECK(main_loop_->BelongsToCurrentThread());
 
   // Tell the data source to abort any pending reads so that the pipeline is
   // not blocked when issuing stop commands to the other filters.
   if (proxy_) {
     proxy_->AbortDataSource();
     if (chunk_demuxer_) {
       chunk_demuxer_->Shutdown();
       chunk_demuxer_ = NULL;
     }
   }
@@ skipping 15 matching lines @@
 
   // And then detach the proxy, it may live on the render thread for a little
   // longer until all the tasks are finished.
   if (proxy_) {
     proxy_->Detach();
     proxy_ = NULL;
   }
 }
 
 WebKit::WebMediaPlayerClient* WebMediaPlayerImpl::GetClient() {
-  DCHECK_EQ(main_loop_, MessageLoop::current());
+  DCHECK(main_loop_->BelongsToCurrentThread());
   DCHECK(client_);
   return client_;
 }
 
 WebKit::WebAudioSourceProvider* WebMediaPlayerImpl::audioSourceProvider() {
   return audio_source_provider_;
 }
 
 void WebMediaPlayerImpl::IncrementExternallyAllocatedMemory() {
-  DCHECK_EQ(main_loop_, MessageLoop::current());
+  DCHECK(main_loop_->BelongsToCurrentThread());
   incremented_externally_allocated_memory_ = true;
   v8::V8::AdjustAmountOfExternalAllocatedMemory(kPlayerExtraMemory);
 }
 
 double WebMediaPlayerImpl::GetPipelineDuration() const {
   base::TimeDelta duration = pipeline_->GetMediaDuration();
 
   // Return positive infinity if the resource is unbounded.
   // http://www.whatwg.org/specs/web-apps/current-work/multipage/video.html#dom-media-duration
   if (duration == media::kInfiniteDuration())
     return std::numeric_limits<double>::infinity();
 
   return duration.InSecondsF();
 }
 
 void WebMediaPlayerImpl::OnDurationChange() {
   if (ready_state_ == WebMediaPlayer::ReadyStateHaveNothing)
     return;
 
   GetClient()->durationChanged();
 }
 
 }  // namespace webkit_media