Pass SessionConfig by reference instead of pointer.

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/message_loop_proxy.h"
 #include "base/rand_util.h"
 #include "base/stl_util.h"
@@ skipping 39 matching lines @@
 JingleSession::JingleSession(
     JingleSessionManager* jingle_session_manager,
     const std::string& local_cert,
     crypto::RSAPrivateKey* local_private_key,
     const std::string& peer_public_key)
     : jingle_session_manager_(jingle_session_manager),
       local_cert_(local_cert),
       state_(INITIALIZING),
       closing_(false),
       cricket_session_(NULL),
+      config_set_(false),
       ALLOW_THIS_IN_INITIALIZER_LIST(task_factory_(this)) {
   // TODO(hclam): Need a better way to clone a key.
   if (local_private_key) {
     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());
   }
 }
@@ skipping 87 matching lines @@
   DCHECK(CalledOnValidThread());
   return control_channel_socket_.get();
 }
 
 net::Socket* JingleSession::event_channel() {
   DCHECK(CalledOnValidThread());
   return event_channel_socket_.get();
 }
 
 const std::string& JingleSession::jid() {
-  // TODO(sergeyu): Fix ChromotingHost so that it doesn't call this
-  // method on invalid thread and uncomment this DCHECK.
-  // See crbug.com/88600 .
-  // DCHECK(CalledOnValidThread());
+  DCHECK(CalledOnValidThread());
   return jid_;
 }
 
 const CandidateSessionConfig* JingleSession::candidate_config() {
   DCHECK(CalledOnValidThread());
   DCHECK(candidate_config_.get());
   return candidate_config_.get();
 }
 
 void JingleSession::set_candidate_config(
     const CandidateSessionConfig* candidate_config) {
   DCHECK(CalledOnValidThread());
   DCHECK(!candidate_config_.get());
   DCHECK(candidate_config);
   candidate_config_.reset(candidate_config);
 }
 
 const std::string& JingleSession::local_certificate() const {
   DCHECK(CalledOnValidThread());
   return local_cert_;
 }
 
-const SessionConfig* JingleSession::config() {
-  // TODO(sergeyu): Fix ChromotingHost so that it doesn't call this
-  // method on invalid thread and uncomment this DCHECK.
-  // See crbug.com/88600 .
-  // DCHECK(CalledOnValidThread());
-  DCHECK(config_.get());
-  return config_.get();
+const SessionConfig& JingleSession::config() {
+  DCHECK(CalledOnValidThread());
+  DCHECK(config_set_);
+  return config_;
 }
 
-void JingleSession::set_config(const SessionConfig* config) {
+void JingleSession::set_config(const SessionConfig& config) {
   DCHECK(CalledOnValidThread());
-  DCHECK(!config_.get());
-  DCHECK(config);
-  config_.reset(config);
+  DCHECK(!config_set_);
+  config_ = config;
+  config_set_ = true;
 }
 
 const std::string& JingleSession::initiator_token() {
   DCHECK(CalledOnValidThread());
   return initiator_token_;
 }
 
 void JingleSession::set_initiator_token(const std::string& initiator_token) {
   DCHECK(CalledOnValidThread());
   initiator_token_ = initiator_token;
@@ skipping 115 matching lines @@
   const protocol::ContentDescription* content_description =
       static_cast<const protocol::ContentDescription*>(content->description);
   CHECK(content_description);
 
   remote_cert_ = content_description->certificate();
   if (remote_cert_.empty()) {
     LOG(ERROR) << "Connection response does not specify certificate";
     return false;
   }
 
-  scoped_ptr<SessionConfig> config(
-      content_description->config()->GetFinalConfig());
-  if (!config.get()) {
+  SessionConfig config;
+  if (!content_description->config()->GetFinalConfig(&config)) {
     LOG(ERROR) << "Connection response does not specify configuration";
     return false;
   }
-  if (!candidate_config()->IsSupported(config.get())) {
+  if (!candidate_config()->IsSupported(config)) {
     LOG(ERROR) << "Connection response specifies an invalid configuration";
     return false;
   }
 
-  set_config(config.release());
+  set_config(config);
   return true;
 }
 
 void JingleSession::OnAccept() {
   DCHECK(CalledOnValidThread());
 
   // If we initiated the session, store the candidate configuration that the
   // host responded with, to refer to later.
   if (cricket_session_->initiator()) {
     if (!InitializeConfigFromDescription(
@@ skipping 108 matching lines @@
     DCHECK_NE(state_, FAILED);
 
     state_ = new_state;
     if (state_change_callback_.get())
       state_change_callback_->Run(new_state);
   }
 }
 
 }  // namespace protocol
 }  // namespace remoting