Update mojo sdk to rev c02a28868825edfa57ab77947b8cb15e741c5598

third_party/mojo/src/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/logging.h"
@@ skipping 21 matching lines @@
     : platform_support_(platform_support),
       is_running_(false),
       is_shutting_down_(false),
       channel_manager_(nullptr) {
 }
 
 void 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
+  // No need to take |mutex_|, since this must be called before this object
   // becomes thread-safe.
   DCHECK(!is_running_);
   raw_channel_ = raw_channel.Pass();
   raw_channel_->Init(this);
   is_running_ = true;
 }
 
 void Channel::SetChannelManager(ChannelManager* channel_manager) {
   DCHECK(channel_manager);
 
-  base::AutoLock locker(lock_);
+  MutexLocker locker(&mutex_);
   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_);
+    MutexLocker locker(&mutex_);
     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) {
     if (it->second) {
       num_live++;
       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_);
+  MutexLocker locker(&mutex_);
   is_shutting_down_ = true;
   channel_manager_ = nullptr;
 }
 
 void Channel::SetBootstrapEndpoint(scoped_refptr<ChannelEndpoint> endpoint) {
   // Used for both local and remote IDs.
   ChannelEndpointId bootstrap_id = ChannelEndpointId::GetBootstrap();
   SetBootstrapEndpointWithIds(endpoint.Pass(), bootstrap_id, bootstrap_id);
 }
 
 void Channel::SetBootstrapEndpointWithIds(
     scoped_refptr<ChannelEndpoint> endpoint,
     ChannelEndpointId local_id,
     ChannelEndpointId remote_id) {
   DCHECK(endpoint);
 
   {
-    base::AutoLock locker(lock_);
+    MutexLocker locker(&mutex_);
 
     DLOG_IF(WARNING, is_shutting_down_)
         << "SetBootstrapEndpoint() while shutting down";
 
     // There must not be an endpoint with that ID already.
     DCHECK(local_id_to_endpoint_map_.find(local_id) ==
            local_id_to_endpoint_map_.end());
 
     local_id_to_endpoint_map_[local_id] = endpoint;
   }
 
   endpoint->AttachAndRun(this, local_id, remote_id);
 }
 
 bool Channel::WriteMessage(scoped_ptr<MessageInTransit> message) {
-  base::AutoLock locker(lock_);
+  MutexLocker locker(&mutex_);
   if (!is_running_) {
     // TODO(vtl): I think this is probably not an error condition, but I should
     // think about it (and the shutdown sequence) more carefully.
     LOG(WARNING) << "WriteMessage() after shutdown";
     return false;
   }
 
   DLOG_IF(WARNING, is_shutting_down_) << "WriteMessage() while shutting down";
   return raw_channel_->WriteMessage(message.Pass());
 }
 
 bool Channel::IsWriteBufferEmpty() {
-  base::AutoLock locker(lock_);
+  MutexLocker locker(&mutex_);
   if (!is_running_)
     return true;
   return raw_channel_->IsWriteBufferEmpty();
 }
 
 void Channel::DetachEndpoint(ChannelEndpoint* endpoint,
                              ChannelEndpointId local_id,
                              ChannelEndpointId remote_id) {
   DCHECK(endpoint);
   DCHECK(local_id.is_valid());
 
   if (!remote_id.is_valid())
     return;  // Nothing to do.
 
   {
-    base::AutoLock locker_(lock_);
+    MutexLocker locker_(&mutex_);
     if (!is_running_)
       return;
 
     IdToEndpointMap::iterator it = local_id_to_endpoint_map_.find(local_id);
     // We detach immediately if we receive a remove message, so it's possible
     // that the local ID is no longer in |local_id_to_endpoint_map_|, or even
     // that it's since been reused for another endpoint. In both cases, there's
     // nothing more to do.
     if (it == local_id_to_endpoint_map_.end() || it->second.get() != endpoint)
       return;
@@ skipping 72 matching lines @@
 
 scoped_refptr<IncomingEndpoint> Channel::DeserializeEndpoint(
     const void* source) {
   const SerializedEndpoint* s = static_cast<const SerializedEndpoint*>(source);
   ChannelEndpointId local_id = s->receiver_endpoint_id;
   // No need to check the validity of |local_id| -- if it's not valid, it simply
   // won't be in |incoming_endpoints_|.
   DVLOG_IF(2, !local_id.is_valid() || !local_id.is_remote())
       << "Attempt to get incoming endpoint for invalid ID " << local_id;
 
-  base::AutoLock locker(lock_);
+  MutexLocker locker(&mutex_);
 
   auto it = incoming_endpoints_.find(local_id);
   if (it == incoming_endpoints_.end()) {
     LOG(ERROR) << "Failed to deserialize endpoint (ID = " << local_id << ")";
     return nullptr;
   }
 
   DVLOG(2) << "Deserializing endpoint (new local ID = " << local_id << ")";
 
   scoped_refptr<IncomingEndpoint> rv;
   rv.swap(it->second);
   incoming_endpoints_.erase(it);
   return rv;
 }
 
 size_t Channel::GetSerializedPlatformHandleSize() const {
+  // TODO(vtl): Having to lock |mutex_| here is a bit unfortunate. Maybe we
+  // should get the size in |Init()| and cache it?
+  MutexLocker locker(&mutex_);
   return raw_channel_->GetSerializedPlatformHandleSize();
 }
 
 Channel::~Channel() {
   // The channel should have been shut down first.
   DCHECK(!is_running_);
 }
 
 void Channel::OnReadMessage(
     const MessageInTransit::View& message_view,
@@ skipping 19 matching lines @@
 
 void Channel::OnError(Error error) {
   DCHECK(creation_thread_checker_.CalledOnValidThread());
 
   switch (error) {
     case ERROR_READ_SHUTDOWN:
       // The other side was cleanly closed, so this isn't actually an error.
       DVLOG(1) << "RawChannel read error (shutdown)";
       break;
     case ERROR_READ_BROKEN: {
-      base::AutoLock locker(lock_);
+      MutexLocker locker(&mutex_);
       LOG_IF(ERROR, !is_shutting_down_)
           << "RawChannel read error (connection broken)";
       break;
     }
     case ERROR_READ_BAD_MESSAGE:
       // Receiving a bad message means either a bug, data corruption, or
       // malicious attack (probably due to some other bug).
       LOG(ERROR) << "RawChannel read error (received bad message)";
       break;
     case ERROR_READ_UNKNOWN:
@@ skipping 16 matching lines @@
          message_view.type() == MessageInTransit::Type::ENDPOINT);
 
   ChannelEndpointId local_id = message_view.destination_id();
   if (!local_id.is_valid()) {
     HandleRemoteError("Received message with no destination ID");
     return;
   }
 
   scoped_refptr<ChannelEndpoint> endpoint;
   {
-    base::AutoLock locker(lock_);
+    MutexLocker locker(&mutex_);
 
     // Since we own |raw_channel_|, and this method and |Shutdown()| should only
     // be called from the creation thread, |raw_channel_| should never be null
     // here.
     DCHECK(is_running_);
 
     IdToEndpointMap::const_iterator it =
         local_id_to_endpoint_map_.find(local_id);
     if (it != local_id_to_endpoint_map_.end()) {
       // Ignore messages for zombie endpoints (not an error).
@@ skipping 98 matching lines @@
     return false;
   }
 
   // Create/initialize an |IncomingEndpoint| and thus an endpoint (outside the
   // lock).
   scoped_refptr<IncomingEndpoint> incoming_endpoint(new IncomingEndpoint());
   scoped_refptr<ChannelEndpoint> endpoint = incoming_endpoint->Init();
 
   bool success = true;
   {
-    base::AutoLock locker(lock_);
+    MutexLocker locker(&mutex_);
 
     if (local_id_to_endpoint_map_.find(local_id) ==
         local_id_to_endpoint_map_.end()) {
       DCHECK(incoming_endpoints_.find(local_id) == incoming_endpoints_.end());
 
       // TODO(vtl): Use emplace when we move to C++11 unordered_maps. (It'll
       // avoid some refcount churn.)
       local_id_to_endpoint_map_[local_id] = endpoint;
       incoming_endpoints_[local_id] = incoming_endpoint;
     } else {
@@ skipping 10 matching lines @@
   endpoint->AttachAndRun(this, local_id, remote_id);
   return true;
 }
 
 bool Channel::OnRemoveEndpoint(ChannelEndpointId local_id,
                                ChannelEndpointId remote_id) {
   DCHECK(creation_thread_checker_.CalledOnValidThread());
 
   scoped_refptr<ChannelEndpoint> endpoint;
   {
-    base::AutoLock locker(lock_);
+    MutexLocker locker(&mutex_);
 
     IdToEndpointMap::iterator it = local_id_to_endpoint_map_.find(local_id);
     if (it == local_id_to_endpoint_map_.end()) {
       DVLOG(2) << "Remove endpoint error: not found";
       return false;
     }
 
     if (!it->second) {
       // Remove messages "crossed"; we have to wait for the ack.
       return true;
@@ skipping 15 matching lines @@
                          static_cast<unsigned>(local_id.value()),
                          static_cast<unsigned>(remote_id.value())).c_str());
   }
 
   return true;
 }
 
 bool Channel::OnRemoveEndpointAck(ChannelEndpointId local_id) {
   DCHECK(creation_thread_checker_.CalledOnValidThread());
 
-  base::AutoLock locker(lock_);
+  MutexLocker locker(&mutex_);
 
   IdToEndpointMap::iterator it = local_id_to_endpoint_map_.find(local_id);
   if (it == local_id_to_endpoint_map_.end()) {
     DVLOG(2) << "Remove endpoint ack error: not found";
     return false;
   }
 
   if (it->second) {
     DVLOG(2) << "Remove endpoint ack error: wrong state";
     return false;
@@ skipping 22 matching lines @@
 // 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) {
   DCHECK(endpoint);
 
   ChannelEndpointId local_id;
   ChannelEndpointId remote_id;
   {
-    base::AutoLock locker(lock_);
+    MutexLocker locker(&mutex_);
 
     DLOG_IF(WARNING, is_shutting_down_)
         << "AttachAndRunEndpoint() while shutting down";
 
     do {
       local_id = local_id_generator_.GetNext();
     } while (local_id_to_endpoint_map_.find(local_id) !=
              local_id_to_endpoint_map_.end());
 
     // TODO(vtl): We also need to check for collisions of remote IDs here.
@@ skipping 24 matching lines @@
            << ", local ID " << local_id << ", remote ID " << remote_id;
   scoped_ptr<MessageInTransit> message(new MessageInTransit(
       MessageInTransit::Type::CHANNEL, subtype, 0, nullptr));
   message->set_source_id(local_id);
   message->set_destination_id(remote_id);
   return WriteMessage(message.Pass());
 }
 
 }  // namespace system
 }  // namespace mojo