Replace ScopedThreadProxy with MessageLoopProxy & WeakPtrs.

remoting/client/chromoting_client.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/chromoting_client.h"
 
 #include "base/bind.h"
 #include "remoting/client/chromoting_view.h"
 #include "remoting/client/client_context.h"
 #include "remoting/client/rectangle_update_decoder.h"
@@ skipping 23 matching lines @@
                                    RectangleUpdateDecoder* rectangle_decoder,
                                    const base::Closure& client_done)
     : config_(config),
       context_(context),
       connection_(connection),
       view_(view),
       rectangle_decoder_(rectangle_decoder),
       client_done_(client_done),
       packet_being_processed_(false),
       last_sequence_number_(0),
-      thread_proxy_(context_->network_message_loop()) {
+      weak_factory_(ALLOW_THIS_IN_INITIALIZER_LIST(this)) {
 }
 
 ChromotingClient::~ChromotingClient() {
 }
 
 void ChromotingClient::Start(
     scoped_refptr<XmppProxy> xmpp_proxy,
     scoped_ptr<protocol::TransportFactory> transport_factory) {
   DCHECK(message_loop()->BelongsToCurrentThread());
 
+  // Create a WeakPtr to ourself for to use for all posted tasks.
+  weak_ptr_ = weak_factory_.GetWeakPtr();
+
   scoped_ptr<protocol::Authenticator> authenticator;
   if (config_.use_v1_authenticator) {
     authenticator.reset(new protocol::V1ClientAuthenticator(
         config_.local_jid, config_.shared_secret));
   } else {
     authenticator = protocol::NegotiatingAuthenticator::CreateForClient(
         config_.authentication_tag,
         config_.shared_secret, config_.authentication_methods);
   }
 
   connection_->Connect(xmpp_proxy, config_.local_jid, config_.host_jid,
                        config_.host_public_key, transport_factory.Pass(),
                        authenticator.Pass(), this, this, this, this);
 
   if (!view_->Initialize()) {
     ClientDone();
   }
 }
 
 void ChromotingClient::Stop(const base::Closure& shutdown_task) {
   if (!message_loop()->BelongsToCurrentThread()) {
     message_loop()->PostTask(
         FROM_HERE, base::Bind(&ChromotingClient::Stop,
-                              base::Unretained(this), shutdown_task));
+                              weak_ptr_, shutdown_task));
     return;
   }
 
   // Drop all pending packets.
   while(!received_packets_.empty()) {
     delete received_packets_.front().packet;
     received_packets_.front().done.Run();
     received_packets_.pop_front();
   }
 
   connection_->Disconnect(base::Bind(&ChromotingClient::OnDisconnected,
-                                     base::Unretained(this), shutdown_task));
+                                     weak_ptr_, shutdown_task));
 }
 
 void ChromotingClient::OnDisconnected(const base::Closure& shutdown_task) {
   view_->TearDown();
 
   shutdown_task.Run();
 }
 
 void ChromotingClient::ClientDone() {
   if (!client_done_.is_null()) {
@@ skipping 84 matching lines @@
   view_->SetConnectionState(state, error);
 }
 
 base::MessageLoopProxy* ChromotingClient::message_loop() {
   return context_->network_message_loop();
 }
 
 void ChromotingClient::OnPacketDone(bool last_packet,
                                     base::Time decode_start) {
   if (!message_loop()->BelongsToCurrentThread()) {
-    thread_proxy_.PostTask(FROM_HERE, base::Bind(
+    message_loop()->PostTask(FROM_HERE, base::Bind(
         &ChromotingClient::OnPacketDone, base::Unretained(this),
         last_packet, decode_start));
     return;
   }
 
   // Record the latency between the final packet being received and
   // presented.
   if (last_packet) {
     stats_.video_decode_ms()->Record(
         (base::Time::Now() - decode_start).InMilliseconds());
   }
 
   received_packets_.front().done.Run();
   received_packets_.pop_front();
 
   packet_being_processed_ = false;
 
   // Process the next video packet.
   DispatchPacket();
 }
 
 void ChromotingClient::Initialize() {
   if (!message_loop()->BelongsToCurrentThread()) {
-    thread_proxy_.PostTask(FROM_HERE, base::Bind(
-        &ChromotingClient::Initialize, base::Unretained(this)));
+    message_loop()->PostTask(FROM_HERE, base::Bind(
+        &ChromotingClient::Initialize, weak_ptr_));
     return;
   }
 
   // Initialize the decoder.
   rectangle_decoder_->Initialize(connection_->config());
 }
 
 }  // namespace remoting