Switch remoting/protocol to new callbacks

remoting/protocol/jingle_session.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/protocol/jingle_session.h"
 
 #include "base/bind.h"
 #include "base/location.h"
 #include "base/message_loop_proxy.h"
 #include "base/rand_util.h"
@@ skipping 48 matching lines @@
     std::vector<uint8> key_bytes;
     CHECK(local_private_key->ExportPrivateKey(&key_bytes));
     local_private_key_.reset(
         crypto::RSAPrivateKey::CreateFromPrivateKeyInfo(key_bytes));
     CHECK(local_private_key_.get());
   }
 }
 
 JingleSession::~JingleSession() {
   // Reset the callback so that it's not called from Close().
-  state_change_callback_.reset();
+  state_change_callback_.Reset();
   Close();
   jingle_session_manager_->SessionDestroyed(this);
 }
 
 void JingleSession::Init(cricket::Session* cricket_session) {
   DCHECK(CalledOnValidThread());
 
   cricket_session_ = cricket_session;
   jid_ = cricket_session_->remote_name();
   cricket_session_->SignalState.connect(
@@ skipping 40 matching lines @@
   // Session may be destroyed only after it is closed.
   DCHECK(state_ == FAILED || state_ == CLOSED);
 
   cricket::Session* session = cricket_session_;
   if (cricket_session_)
     cricket_session_->SignalState.disconnect(this);
   cricket_session_ = NULL;
   return session;
 }
 
-void JingleSession::SetStateChangeCallback(StateChangeCallback* callback) {
+void JingleSession::SetStateChangeCallback(
+    const StateChangeCallback& callback) {
   DCHECK(CalledOnValidThread());
-  DCHECK(callback);
-  state_change_callback_.reset(callback);
+  DCHECK(!callback.is_null());
+  state_change_callback_ = callback;
 }
 
 Session::Error JingleSession::error() {
   DCHECK(CalledOnValidThread());
   return error_;
 }
 
 void JingleSession::CreateStreamChannel(
       const std::string& name, const StreamChannelCallback& callback) {
   DCHECK(CalledOnValidThread());
@@ skipping 315 matching lines @@
 }
 
 void JingleSession::SetState(State new_state) {
   DCHECK(CalledOnValidThread());
 
   if (new_state != state_) {
     DCHECK_NE(state_, CLOSED);
     DCHECK_NE(state_, FAILED);
 
     state_ = new_state;
-    if (state_change_callback_.get())
-      state_change_callback_->Run(new_state);
+    if (!state_change_callback_.is_null())
+      state_change_callback_.Run(new_state);
   }
 }
 
 }  // namespace protocol
 }  // namespace remoting