Update mojo sdk to rev f6c8ec07c01deebc13178d516225fd12695c3dc2

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 54 matching lines @@
     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.get()) {
+    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_);
   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());
+  DCHECK(endpoint);
 
   ChannelEndpointId local_id;
   ChannelEndpointId remote_id;
   {
     base::AutoLock locker(lock_);
 
     DLOG_IF(WARNING, is_shutting_down_)
         << "AttachEndpoint() while shutting down";
 
     if (is_bootstrap) {
@@ skipping 67 matching lines @@
       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;
 
-    DCHECK(it->second.get());
+    DCHECK(it->second);
     it->second = nullptr;
 
     // Send a remove message outside the lock.
   }
 
   if (!SendControlMessage(
           MessageInTransit::kSubtypeChannelRemoveMessagePipeEndpoint, local_id,
           remote_id)) {
     HandleLocalError(base::StringPrintf(
         "Failed to send message to remove remote message pipe endpoint (local "
@@ skipping 100 matching lines @@
 
     // 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).
-      if (!it->second.get()) {
+      if (!it->second) {
         DVLOG(2) << "Ignoring downstream message for zombie endpoint (local ID "
                     "= " << local_id
                  << ", remote ID = " << message_view.source_id() << ")";
         return;
       }
 
       endpoint = it->second;
     }
   }
-  if (!endpoint.get()) {
+  if (!endpoint) {
     HandleRemoteError(base::StringPrintf(
         "Received a message for nonexistent local destination ID %u",
         static_cast<unsigned>(local_id.value())));
     // This is strongly indicative of some problem. However, it's not a fatal
     // error, since it may indicate a buggy (or hostile) remote process. Don't
     // die even for Debug builds, since handling this properly needs to be
     // tested (TODO(vtl)).
     DLOG(ERROR) << "This should not happen under normal operation.";
     return;
   }
@@ skipping 116 matching lines @@
   scoped_refptr<ChannelEndpoint> endpoint;
   {
     base::AutoLock locker(lock_);
 
     IdToEndpointMap::iterator it = local_id_to_endpoint_map_.find(local_id);
     if (it == local_id_to_endpoint_map_.end()) {
       DVLOG(2) << "Remove message pipe endpoint error: not found";
       return false;
     }
 
-    if (!it->second.get()) {
+    if (!it->second) {
       // Remove messages "crossed"; we have to wait for the ack.
       return true;
     }
 
     endpoint = it->second;
     local_id_to_endpoint_map_.erase(it);
     // Detach and send the remove ack message outside the lock.
   }
 
   endpoint->DetachFromChannel();
@@ skipping 15 matching lines @@
   DCHECK(creation_thread_checker_.CalledOnValidThread());
 
   base::AutoLock locker(lock_);
 
   IdToEndpointMap::iterator it = local_id_to_endpoint_map_.find(local_id);
   if (it == local_id_to_endpoint_map_.end()) {
     DVLOG(2) << "Remove message pipe endpoint ack error: not found";
     return false;
   }
 
-  if (it->second.get()) {
+  if (it->second) {
     DVLOG(2) << "Remove message pipe endpoint ack error: wrong state";
     return false;
   }
 
   local_id_to_endpoint_map_.erase(it);
   return true;
 }
 
 bool Channel::SendControlMessage(MessageInTransit::Subtype subtype,
                                  ChannelEndpointId local_id,
@@ skipping 17 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