Remove unnecessary SupportsWeakPtr base from ChromotingInstance.

remoting/client/plugin/chromoting_instance.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/chromoting_instance.h"
 
 #include <string>
 #include <vector>
 
 #include "base/bind.h"
@@ skipping 276 matching lines @@
         !ParseAuthMethods(auth_methods, &config) ||
         !data->GetString("authenticationTag", &config.authentication_tag)) {
       LOG(ERROR) << "Invalid connect() data.";
       return;
     }
     data->GetString("clientPairingId", &config.client_pairing_id);
     data->GetString("clientPairedSecret", &config.client_paired_secret);
     if (use_async_pin_dialog_) {
       config.fetch_secret_callback =
           base::Bind(&ChromotingInstance::FetchSecretFromDialog,
-                     this->AsWeakPtr());
+                     weak_factory_.GetWeakPtr());
     } else {
       std::string shared_secret;
       if (!data->GetString("sharedSecret", &shared_secret)) {
         LOG(ERROR) << "sharedSecret not specified in connect().";
         return;
       }
       config.fetch_secret_callback =
           base::Bind(&ChromotingInstance::FetchSecretFromString, shared_secret);
     }
 
@@ skipping 257 matching lines @@
 
 protocol::CursorShapeStub* ChromotingInstance::GetCursorShapeStub() {
   // TODO(sergeyu): Move cursor shape code to a separate class.
   // crbug.com/138108
   return this;
 }
 
 scoped_ptr<protocol::ThirdPartyClientAuthenticator::TokenFetcher>
 ChromotingInstance::GetTokenFetcher(const std::string& host_public_key) {
   return scoped_ptr<protocol::ThirdPartyClientAuthenticator::TokenFetcher>(
-      new PepperTokenFetcher(this->AsWeakPtr(), host_public_key));
+      new PepperTokenFetcher(weak_factory_.GetWeakPtr(), host_public_key));
 }
 
 void ChromotingInstance::InjectClipboardEvent(
     const protocol::ClipboardEvent& event) {
   scoped_ptr<base::DictionaryValue> data(new base::DictionaryValue());
   data->SetString("mimeType", event.mime_type());
   data->SetString("item", event.data());
   PostChromotingMessage("injectClipboardItem", data.Pass());
 }
 
@@ skipping 108 matching lines @@
   // Connect the input pipeline to the protocol stub & initialize components.
   mouse_input_filter_.set_input_stub(host_connection_->input_stub());
   mouse_input_filter_.set_input_size(view_->get_view_size_dips());
 
   LOG(INFO) << "Connecting to " << config.host_jid
             << ". Local jid: " << config.local_jid << ".";
 
   // Setup the PepperSignalStrategy.
   signal_strategy_.reset(new PepperSignalStrategy(
       config.local_jid,
-      base::Bind(&ChromotingInstance::SendOutgoingIq, AsWeakPtr())));
+      base::Bind(&ChromotingInstance::SendOutgoingIq,
+                 weak_factory_.GetWeakPtr())));
 
   scoped_ptr<cricket::HttpPortAllocatorBase> port_allocator(
       PepperPortAllocator::Create(this));
   scoped_ptr<protocol::TransportFactory> transport_factory(
       new protocol::LibjingleTransportFactory(port_allocator.Pass(), false));
 
   // Kick off the connection.
   client_->Start(signal_strategy_.get(), transport_factory.Pass());
 
   // Start timer that periodically sends perf stats.
   plugin_task_runner_->PostDelayedTask(
-      FROM_HERE, base::Bind(&ChromotingInstance::SendPerfStats, AsWeakPtr()),
+      FROM_HERE, base::Bind(&ChromotingInstance::SendPerfStats,
+                            weak_factory_.GetWeakPtr()),
       base::TimeDelta::FromMilliseconds(kPerfStatsIntervalMs));
 }
 
 void ChromotingInstance::Disconnect() {
   DCHECK(plugin_task_runner_->BelongsToCurrentThread());
 
   // PepperView must be destroyed before the client.
   view_.reset();
 
   LOG(INFO) << "Disconnecting from host.";
@@ skipping 140 matching lines @@
   data->SetString("iq", iq);
   PostChromotingMessage("sendOutgoingIq", data.Pass());
 }
 
 void ChromotingInstance::SendPerfStats() {
   if (!client_.get()) {
     return;
   }
 
   plugin_task_runner_->PostDelayedTask(
-      FROM_HERE, base::Bind(&ChromotingInstance::SendPerfStats, AsWeakPtr()),
+      FROM_HERE, base::Bind(&ChromotingInstance::SendPerfStats,
+                            weak_factory_.GetWeakPtr()),
       base::TimeDelta::FromMilliseconds(kPerfStatsIntervalMs));
 
   scoped_ptr<base::DictionaryValue> data(new base::DictionaryValue());
   ChromotingStats* stats = client_->GetStats();
   data->SetDouble("videoBandwidth", stats->video_bandwidth()->Rate());
   data->SetDouble("videoFrameRate", stats->video_frame_rate()->Rate());
   data->SetDouble("captureLatency", stats->video_capture_ms()->Average());
   data->SetDouble("encodeLatency", stats->video_encode_ms()->Average());
   data->SetDouble("decodeLatency", stats->video_decode_ms()->Average());
   data->SetDouble("renderLatency", stats->video_paint_ms()->Average());
@@ skipping 118 matching lines @@
                                       url_components.scheme.len);
   return url_scheme == kChromeExtensionUrlScheme;
 }
 
 bool ChromotingInstance::IsConnected() {
   return host_connection_.get() &&
     (host_connection_->state() == protocol::ConnectionToHost::CONNECTED);
 }
 
 }  // namespace remoting