Switch remoting/protocol to new callbacks

remoting/protocol/pepper_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/pepper_session.h"
 
 #include "base/bind.h"
 #include "base/rand_util.h"
 #include "base/stl_util.h"
 #include "base/string_number_conversions.h"
@@ skipping 26 matching lines @@
       error_(OK) {
 }
 
 PepperSession::~PepperSession() {
   control_channel_socket_.reset();
   event_channel_socket_.reset();
   STLDeleteContainerPairSecondPointers(channels_.begin(), channels_.end());
   session_manager_->SessionDestroyed(this);
 }
 
-void PepperSession::SetStateChangeCallback(StateChangeCallback* callback) {
+void PepperSession::SetStateChangeCallback(
+    const StateChangeCallback& callback) {
   DCHECK(CalledOnValidThread());
-  state_change_callback_.reset(callback);
+  state_change_callback_ = callback;
 }
 
 Session::Error PepperSession::error() {
   DCHECK(CalledOnValidThread());
   return error_;
 }
 
 void PepperSession::StartConnection(
     const std::string& peer_jid,
     const std::string& peer_public_key,
     const std::string& client_token,
     CandidateSessionConfig* config,
-    Session::StateChangeCallback* state_change_callback) {
+    const StateChangeCallback& state_change_callback) {
   DCHECK(CalledOnValidThread());
 
   peer_jid_ = peer_jid;
   peer_public_key_ = peer_public_key;
   initiator_token_ = client_token;
   candidate_config_.reset(config);
-  state_change_callback_.reset(state_change_callback);
+  state_change_callback_ = state_change_callback;
 
   // Generate random session ID. There are usually not more than 1
   // concurrent session per host, so a random 64-bit integer provides
   // enough entropy. In the worst case connection will fail when two
   // clients generate the same session ID concurrently.
   session_id_ = base::Int64ToString(base::RandGenerator(kint64max));
 
   // Send session-initiate message.
   JingleMessage message(peer_jid_, JingleMessage::SESSION_INITIATE,
                         session_id_);
@@ skipping 295 matching lines @@
 }
 
 void PepperSession::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