Move code in src/remoting to the new callbacks.

remoting/client/chromoting_client.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/chromoting_client.h"
 
 #include "base/bind.h"
 #include "remoting/client/chromoting_view.h"
 #include "remoting/client/client_context.h"
 #include "remoting/client/input_handler.h"
@@ skipping 10 matching lines @@
 
 ChromotingClient::QueuedVideoPacket::~QueuedVideoPacket() {
 }
 
 ChromotingClient::ChromotingClient(const ClientConfig& config,
                                    ClientContext* context,
                                    protocol::ConnectionToHost* connection,
                                    ChromotingView* view,
                                    RectangleUpdateDecoder* rectangle_decoder,
                                    InputHandler* input_handler,
-                                   Task* client_done)
+                                   const base::Closure& client_done)
     : config_(config),
       context_(context),
       connection_(connection),
       view_(view),
       rectangle_decoder_(rectangle_decoder),
       input_handler_(input_handler),
       client_done_(client_done),
       packet_being_processed_(false),
       last_sequence_number_(0),
       thread_proxy_(context_->network_message_loop()) {
@@ skipping 26 matching lines @@
                                      base::Unretained(this), shutdown_task));
 }
 
 void ChromotingClient::OnDisconnected(const base::Closure& shutdown_task) {
   view_->TearDown();
 
   shutdown_task.Run();
 }
 
 void ChromotingClient::ClientDone() {
-  if (client_done_ != NULL) {
+  if (!client_done_.is_null()) {
     message_loop()->PostTask(FROM_HERE, client_done_);
+    client_done_.Reset();
   }
 }
 
 ChromotingStats* ChromotingClient::GetStats() {
   return &stats_;
 }
 
 void ChromotingClient::Repaint() {
   DCHECK(message_loop()->BelongsToCurrentThread());
   view_->Paint();
@@ skipping 49 matching lines @@
   const VideoPacket* packet = received_packets_.front().packet;
   packet_being_processed_ = true;
 
   // Measure the latency between the last packet being received and presented.
   bool last_packet = (packet->flags() & VideoPacket::LAST_PACKET) != 0;
   base::Time decode_start;
   if (last_packet)
     decode_start = base::Time::Now();
 
   rectangle_decoder_->DecodePacket(
-      packet, NewRunnableMethod(this, &ChromotingClient::OnPacketDone,
-                                last_packet, decode_start));
+      packet, base::Bind(&ChromotingClient::OnPacketDone,
+                         base::Unretained(this), last_packet, decode_start));
 }
 
 void ChromotingClient::OnConnectionState(
     protocol::ConnectionToHost::State state,
     protocol::ConnectionToHost::Error error) {
   DCHECK(message_loop()->BelongsToCurrentThread());
   VLOG(1) << "ChromotingClient::OnConnectionState(" << state << ")";
   if (state == protocol::ConnectionToHost::CONNECTED ||
       state == protocol::ConnectionToHost::AUTHENTICATED)
     Initialize();
@@ skipping 37 matching lines @@
   }
 
   // Initialize the decoder.
   rectangle_decoder_->Initialize(connection_->config());
 
   // Schedule the input handler to process the event queue.
   input_handler_->Initialize();
 }
 
 }  // namespace remoting