Cleanups in WebrtcTransport.

remoting/protocol/webrtc_data_stream_adapter.cc

 // Copyright 2015 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/webrtc_data_stream_adapter.h"
 
 #include "base/callback.h"
 #include "base/callback_helpers.h"
 #include "base/location.h"
 #include "base/thread_task_runner_handle.h"
@@ skipping 191 matching lines @@
 }
 
 WebrtcDataStreamAdapter::WebrtcDataStreamAdapter() : weak_factory_(this) {}
 
 WebrtcDataStreamAdapter::~WebrtcDataStreamAdapter() {
   DCHECK(pending_channels_.empty());
 }
 
 void WebrtcDataStreamAdapter::Initialize(
     rtc::scoped_refptr<webrtc::PeerConnectionInterface> peer_connection,
-    bool is_server) {
+    bool outgoing) {
   peer_connection_ = peer_connection;
-  is_server_ = is_server;
+  outgoing_ = outgoing;
 
- if (!is_server_) {
+ if (outgoing_) {
     for (auto& channel : pending_channels_) {
       webrtc::DataChannelInit config;
       config.reliable = true;
       channel.second->Start(
           peer_connection_->CreateDataChannel(channel.first, &config));
     }
  }
 }
 
 void WebrtcDataStreamAdapter::OnIncomingDataChannel(
     webrtc::DataChannelInterface* data_channel) {
   auto it = pending_channels_.find(data_channel->label());
-  if (!is_server_ || it == pending_channels_.end()) {
+  if (outgoing_ || it == pending_channels_.end()) {
     LOG(ERROR) << "Received unexpected data channel " << data_channel->label();
     return;
   }
   it->second->Start(data_channel);
 }
 
 void WebrtcDataStreamAdapter::CreateChannel(
     const std::string& name,
     const ChannelCreatedCallback& callback) {
   DCHECK(pending_channels_.find(name) == pending_channels_.end());
 
   Channel* channel =
       new Channel(base::Bind(&WebrtcDataStreamAdapter::OnChannelConnected,
                              base::Unretained(this), callback));
   pending_channels_[name] = channel;
 
-  if (peer_connection_ && !is_server_) {
+  if (peer_connection_ && outgoing_) {
     webrtc::DataChannelInit config;
     config.reliable = true;
     channel->Start(peer_connection_->CreateDataChannel(name, &config));
   }
 }
 
 void WebrtcDataStreamAdapter::CancelChannelCreation(const std::string& name) {
   auto it = pending_channels_.find(name);
   DCHECK(it != pending_channels_.end());
   delete it->second;
@@ skipping 10 matching lines @@
 
   // The callback can delete the channel which also holds the callback
   // object which may cause crash if the callback carries some arguments. Copy
   // the callback to stack to avoid this problem.
   ChannelCreatedCallback callback = connected_callback;
   callback.Run(make_scoped_ptr(channel));
 }
 
 }  // namespace protocol
 }  // namespace remoting