MessageLoopProxy cleanups in remoting client.

remoting/client/plugin/pepper_view.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 "remoting/client/plugin/pepper_view.h"
 
 #include <functional>
 
 #include "base/message_loop.h"
 #include "base/string_util.h"
@@ skipping 78 matching lines @@
 
 bool PepperView::Initialize() {
   DCHECK(!is_initialized_);
 
   is_initialized_ = true;
   InitiateDrawing();
   return true;
 }
 
 void PepperView::TearDown() {
-  DCHECK(context_->main_message_loop()->BelongsToCurrentThread());
+  DCHECK(context_->main_task_runner()->BelongsToCurrentThread());
   DCHECK(is_initialized_);
 
   is_initialized_ = false;
 
   // The producer should now return any pending buffers. At this point, however,
   // ReturnBuffer() tasks scheduled by the producer will not be delivered,
   // so we free all the buffers once the producer's queue is empty.
   base::WaitableEvent done_event(true, false);
   producer_->RequestReturnBuffers(
       base::Bind(&base::WaitableEvent::Signal, base::Unretained(&done_event)));
   done_event.Wait();
 
   merge_buffer_ = NULL;
   while (!buffers_.empty()) {
     FreeBuffer(buffers_.front());
   }
 }
 
 void PepperView::SetConnectionState(protocol::ConnectionToHost::State state,
                                     protocol::ErrorCode error) {
-  DCHECK(context_->main_message_loop()->BelongsToCurrentThread());
+  DCHECK(context_->main_task_runner()->BelongsToCurrentThread());
 
   switch (state) {
     case protocol::ConnectionToHost::CONNECTING:
       instance_->SetConnectionState(
           ChromotingInstance::STATE_CONNECTING,
           ConvertConnectionError(error));
       break;
 
     case protocol::ConnectionToHost::CONNECTED:
       instance_->SetConnectionState(
@@ skipping 50 matching lines @@
   if (view_changed) {
     producer_->SetOutputSizeAndClip(view_size_, clip_area_);
     InitiateDrawing();
   }
 }
 
 void PepperView::ApplyBuffer(const SkISize& view_size,
                              const SkIRect& clip_area,
                              pp::ImageData* buffer,
                              const SkRegion& region) {
-  DCHECK(context_->main_message_loop()->BelongsToCurrentThread());
+  DCHECK(context_->main_task_runner()->BelongsToCurrentThread());
 
   if (!frame_received_) {
     instance_->OnFirstFrameReceived();
     frame_received_ = true;
   }
   // Currently we cannot use the data in the buffer is scale factor has changed
   // already.
   // TODO(alexeypa): We could rescale and draw it (or even draw it without
   // rescaling) to reduce the perceived lag while we are waiting for
   // the properly scaled data.
   if (view_size_ != view_size) {
     FreeBuffer(buffer);
     InitiateDrawing();
   } else {
     FlushBuffer(clip_area, buffer, region);
   }
 }
 
 void PepperView::ReturnBuffer(pp::ImageData* buffer) {
-  DCHECK(context_->main_message_loop()->BelongsToCurrentThread());
+  DCHECK(context_->main_task_runner()->BelongsToCurrentThread());
 
   // Free the buffer if there is nothing to paint.
   if (!is_initialized_) {
     FreeBuffer(buffer);
     return;
   }
 
   // Reuse the buffer if it is large enough, otherwise drop it on the floor
   // and allocate a new one.
   if (buffer->size().width() >= clip_area_.width() &&
       buffer->size().height() >= clip_area_.height()) {
     producer_->DrawBuffer(buffer);
   } else {
     FreeBuffer(buffer);
     InitiateDrawing();
   }
 }
 
 void PepperView::SetSourceSize(const SkISize& source_size) {
-  DCHECK(context_->main_message_loop()->BelongsToCurrentThread());
+  DCHECK(context_->main_task_runner()->BelongsToCurrentThread());
 
   if (source_size_ == source_size)
     return;
 
   source_size_ = source_size;
 
   // Notify JavaScript of the change in source size.
   instance_->SetDesktopSize(source_size.width(), source_size.height());
 }
 
@@ skipping 88 matching lines @@
   int error = graphics2d_.Flush(
       PpCompletionCallback(base::Bind(
           &PepperView::OnFlushDone, AsWeakPtr(), start_time, buffer)));
   CHECK(error == PP_OK_COMPLETIONPENDING);
   flush_pending_ = true;
 }
 
 void PepperView::OnFlushDone(base::Time paint_start,
                              pp::ImageData* buffer,
                              int result) {
-  DCHECK(context_->main_message_loop()->BelongsToCurrentThread());
+  DCHECK(context_->main_task_runner()->BelongsToCurrentThread());
   DCHECK(flush_pending_);
 
   instance_->GetStats()->video_paint_ms()->Record(
       (base::Time::Now() - paint_start).InMilliseconds());
 
   flush_pending_ = false;
   ReturnBuffer(buffer);
 
   // If there is a buffer queued for rendering then render it now.
   if (merge_buffer_ != NULL) {
     buffer = merge_buffer_;
     merge_buffer_ = NULL;
     FlushBuffer(merge_clip_area_, buffer, merge_region_);
   }
 }
 
 }  // namespace remoting