Update mojo sdk to rev afb4440fd5a10cba980878c326180b7ad7960480

mojo/edk/system/channel.cc

 // Copyright 2013 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 "mojo/edk/system/channel.h"
 
 #include <algorithm>
 
 #include "base/bind.h"
 #include "base/compiler_specific.h"
 #include "base/logging.h"
 #include "base/macros.h"
 #include "base/strings/stringprintf.h"
 #include "mojo/edk/embedder/platform_handle_vector.h"
 #include "mojo/edk/system/transport_data.h"
 
 namespace mojo {
 namespace system {
 
 Channel::Channel(embedder::PlatformSupport* platform_support)
     : platform_support_(platform_support),
       is_running_(false),
-      is_shutting_down_(false) {
+      is_shutting_down_(false),
+      channel_manager_(nullptr) {
 }
 
 bool Channel::Init(scoped_ptr<RawChannel> raw_channel) {
   DCHECK(creation_thread_checker_.CalledOnValidThread());
   DCHECK(raw_channel);
 
   // No need to take |lock_|, since this must be called before this object
   // becomes thread-safe.
   DCHECK(!is_running_);
   raw_channel_ = raw_channel.Pass();
 
   if (!raw_channel_->Init(this)) {
     raw_channel_.reset();
     return false;
   }
 
   is_running_ = true;
   return true;
 }
 
+void Channel::SetChannelManager(ChannelManager* channel_manager) {
+  DCHECK(channel_manager);
+
+  base::AutoLock locker(lock_);
+  DCHECK(!is_shutting_down_);
+  DCHECK(!channel_manager_);
+  channel_manager_ = channel_manager;
+}
+
 void Channel::Shutdown() {
   DCHECK(creation_thread_checker_.CalledOnValidThread());
 
   IdToEndpointMap to_destroy;
   {
     base::AutoLock locker(lock_);
     if (!is_running_)
       return;
 
     // Note: Don't reset |raw_channel_|, in case we're being called from within
     // |OnReadMessage()| or |OnError()|.
     raw_channel_->Shutdown();
     is_running_ = false;
 
     // We need to deal with it outside the lock.
     std::swap(to_destroy, local_id_to_endpoint_map_);
   }
 
   size_t num_live = 0;
   size_t num_zombies = 0;
   for (IdToEndpointMap::iterator it = to_destroy.begin();
-       it != to_destroy.end();
-       ++it) {
+       it != to_destroy.end(); ++it) {
     if (it->second.get()) {
       num_live++;
       it->second->OnDisconnect();
       it->second->DetachFromChannel();
     } else {
       num_zombies++;
     }
   }
   DVLOG_IF(2, num_live || num_zombies) << "Shut down Channel with " << num_live
                                        << " live endpoints and " << num_zombies
                                        << " zombies";
 }
 
 void Channel::WillShutdownSoon() {
   base::AutoLock locker(lock_);
   is_shutting_down_ = true;
+  channel_manager_ = nullptr;
 }
 
 // Note: |endpoint| being a |scoped_refptr| makes this function safe, since it
 // keeps the endpoint alive even after the lock is released. Otherwise, there's
 // the temptation to simply pass the result of |new ChannelEndpoint(...)|
 // directly to this function, which wouldn't be sufficient for safety.
 ChannelEndpointId Channel::AttachAndRunEndpoint(
     scoped_refptr<ChannelEndpoint> endpoint,
     bool is_bootstrap) {
   DCHECK(endpoint.get());
@@ skipping 20 matching lines @@
 
       // TODO(vtl): We also need to check for collisions of remote IDs here.
       remote_id = remote_id_generator_.GetNext();
     }
 
     local_id_to_endpoint_map_[local_id] = endpoint;
   }
 
   if (!is_bootstrap) {
     if (!SendControlMessage(
-            MessageInTransit::kSubtypeChannelAttachAndRunEndpoint,
-            local_id,
+            MessageInTransit::kSubtypeChannelAttachAndRunEndpoint, local_id,
             remote_id)) {
       HandleLocalError(base::StringPrintf(
           "Failed to send message to run remote message pipe endpoint (local "
           "ID %u, remote ID %u)",
           static_cast<unsigned>(local_id.value()),
           static_cast<unsigned>(remote_id.value())));
       // TODO(vtl): Should we continue on to |AttachAndRun()|?
     }
   }
 
@@ skipping 43 matching lines @@
     if (it == local_id_to_endpoint_map_.end() || it->second.get() != endpoint)
       return;
 
     DCHECK(it->second.get());
     it->second = nullptr;
 
     // Send a remove message outside the lock.
   }
 
   if (!SendControlMessage(
-          MessageInTransit::kSubtypeChannelRemoveMessagePipeEndpoint,
-          local_id,
+          MessageInTransit::kSubtypeChannelRemoveMessagePipeEndpoint, local_id,
           remote_id)) {
     HandleLocalError(base::StringPrintf(
         "Failed to send message to remove remote message pipe endpoint (local "
         "ID %u, remote ID %u)",
         static_cast<unsigned>(local_id.value()),
         static_cast<unsigned>(remote_id.value())));
   }
 }
 
 scoped_refptr<MessagePipe> Channel::PassIncomingMessagePipe(
@@ skipping 252 matching lines @@
 
     endpoint = it->second;
     local_id_to_endpoint_map_.erase(it);
     // Detach and send the remove ack message outside the lock.
   }
 
   endpoint->DetachFromChannel();
 
   if (!SendControlMessage(
           MessageInTransit::kSubtypeChannelRemoveMessagePipeEndpointAck,
-          local_id,
-          remote_id)) {
+          local_id, remote_id)) {
     HandleLocalError(base::StringPrintf(
         "Failed to send message to remove remote message pipe endpoint ack "
         "(local ID %u, remote ID %u)",
         static_cast<unsigned>(local_id.value()),
         static_cast<unsigned>(remote_id.value())));
   }
 
   endpoint->OnDisconnect();
   return true;
 }
@@ skipping 40 matching lines @@
   // TODO(vtl): Is this how we really want to handle this?
   // Sometimes we'll want to propagate the error back to the message pipe
   // (endpoint), and notify it that the remote is (effectively) closed.
   // Sometimes we'll want to kill the channel (and notify all the endpoints that
   // their remotes are dead.
   LOG(WARNING) << error_message;
 }
 
 }  // namespace system
 }  // namespace mojo