Move code in src/remoting to the new callbacks.

remoting/client/plugin/pepper_view_proxy.cc

 // Copyright (c) 2011 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_proxy.h"
 
 #include "base/message_loop.h"
 #include "remoting/client/client_context.h"
 #include "remoting/client/plugin/chromoting_instance.h"
 
@@ skipping 12 matching lines @@
 bool PepperViewProxy::Initialize() {
   // This method needs a return value so we can't post a task and process on
   // another thread so just return true since PepperView doesn't do anything
   // either.
   return true;
 }
 
 void PepperViewProxy::TearDown() {
   if (instance_ && !plugin_message_loop_->BelongsToCurrentThread()) {
     plugin_message_loop_->PostTask(
-        FROM_HERE, NewRunnableMethod(this, &PepperViewProxy::TearDown));
+        FROM_HERE, base::Bind(&PepperViewProxy::TearDown, this));
     return;
   }
 
   if (view_)
     view_->TearDown();
 }
 
 void PepperViewProxy::Paint() {
   if (instance_ && !plugin_message_loop_->BelongsToCurrentThread()) {
     plugin_message_loop_->PostTask(
-        FROM_HERE, NewRunnableMethod(this, &PepperViewProxy::Paint));
+        FROM_HERE, base::Bind(&PepperViewProxy::Paint, this));
     return;
   }
 
   if (view_)
     view_->Paint();
 }
 
 void PepperViewProxy::SetSolidFill(uint32 color) {
   if (instance_ && !plugin_message_loop_->BelongsToCurrentThread()) {
-    plugin_message_loop_->PostTask(FROM_HERE, NewRunnableMethod(
-        this, &PepperViewProxy::SetSolidFill, color));
+    plugin_message_loop_->PostTask(FROM_HERE, base::Bind(
+        &PepperViewProxy::SetSolidFill, this, color));
     return;
   }
 
   if (view_)
     view_->SetSolidFill(color);
 }
 
 void PepperViewProxy::UnsetSolidFill() {
   if (instance_ && !plugin_message_loop_->BelongsToCurrentThread()) {
     plugin_message_loop_->PostTask(
-        FROM_HERE, NewRunnableMethod(this, &PepperViewProxy::UnsetSolidFill));
+        FROM_HERE, base::Bind(&PepperViewProxy::UnsetSolidFill, this));
     return;
   }
 
   if (view_)
     view_->UnsetSolidFill();
 }
 
 void PepperViewProxy::SetConnectionState(
     protocol::ConnectionToHost::State state,
     protocol::ConnectionToHost::Error error) {
   if (instance_ && !plugin_message_loop_->BelongsToCurrentThread()) {
-    plugin_message_loop_->PostTask(FROM_HERE, NewRunnableMethod(
-        this, &PepperViewProxy::SetConnectionState, state, error));
+    plugin_message_loop_->PostTask(FROM_HERE, base::Bind(
+        &PepperViewProxy::SetConnectionState, this, state, error));
     return;
   }
 
   if (view_)
     view_->SetConnectionState(state, error);
 }
 
 double PepperViewProxy::GetHorizontalScaleRatio() const {
   // This method returns a value, so must run synchronously, so must be
   // called only on the pepper thread.
   DCHECK(plugin_message_loop_->BelongsToCurrentThread());
 
   if (view_)
     return view_->GetHorizontalScaleRatio();
   return 1.0;
 }
 
 double PepperViewProxy::GetVerticalScaleRatio() const {
   // This method returns a value, so must run synchronously, so must be
   // called only on the pepper thread.
   DCHECK(plugin_message_loop_->BelongsToCurrentThread());
 
   if (view_)
     return view_->GetVerticalScaleRatio();
   return 1.0;
 }
 
 void PepperViewProxy::AllocateFrame(
     media::VideoFrame::Format format,
-    size_t width,
-    size_t height,
-    base::TimeDelta timestamp,
-    base::TimeDelta duration,
+    const SkISize& size,
     scoped_refptr<media::VideoFrame>* frame_out,
-    Task* done) {
+    const base::Closure& done) {
   if (instance_ && !plugin_message_loop_->BelongsToCurrentThread()) {
-    plugin_message_loop_->PostTask(FROM_HERE, NewRunnableMethod(
-        this, &PepperViewProxy::AllocateFrame, format, width,
-        height, timestamp, duration, frame_out, done));
+    plugin_message_loop_->PostTask(FROM_HERE, base::Bind(
+        &PepperViewProxy::AllocateFrame, this, format, size, frame_out, done));
     return;
   }
 
   if (view_) {
-    view_->AllocateFrame(format, width, height, timestamp, duration, frame_out,
-                         done);
+    view_->AllocateFrame(format, size, frame_out, done);
   }
 }
 
 void PepperViewProxy::ReleaseFrame(media::VideoFrame* frame) {
   if (instance_ && !plugin_message_loop_->BelongsToCurrentThread()) {
-    plugin_message_loop_->PostTask(FROM_HERE, NewRunnableMethod(
-        this, &PepperViewProxy::ReleaseFrame, make_scoped_refptr(frame)));
+    plugin_message_loop_->PostTask(FROM_HERE, base::Bind(
+        &PepperViewProxy::ReleaseFrame, this, make_scoped_refptr(frame)));
     return;
   }
 
   if (view_)
     view_->ReleaseFrame(frame);
 }
 
 void PepperViewProxy::OnPartialFrameOutput(media::VideoFrame* frame,
                                            RectVector* rects,
-                                           Task* done) {
+                                           const base::Closure& done) {
   if (instance_ && !plugin_message_loop_->BelongsToCurrentThread()) {
-    plugin_message_loop_->PostTask(FROM_HERE, NewRunnableMethod(
-        this, &PepperViewProxy::OnPartialFrameOutput,
+    plugin_message_loop_->PostTask(FROM_HERE, base::Bind(
+        &PepperViewProxy::OnPartialFrameOutput, this,
         make_scoped_refptr(frame), rects, done));
     return;
   }
 
   if (view_)
     view_->OnPartialFrameOutput(frame, rects, done);
 }
 
 void PepperViewProxy::Detach() {
   DCHECK(plugin_message_loop_->BelongsToCurrentThread());
   instance_ = NULL;
   view_ = NULL;
 }
 
 }  // namespace remoting