EDK: Add mojo::util::StringPrintf() (etc.) and convert away from base's.

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 <utility>
 
 #include "base/bind.h"
 #include "base/logging.h"
-#include "base/strings/stringprintf.h"
 #include "mojo/edk/system/endpoint_relayer.h"
 #include "mojo/edk/system/transport_data.h"
+#include "mojo/edk/util/string_printf.h"
 
 using mojo::platform::ScopedPlatformHandle;
 using mojo::util::MakeRefCounted;
 using mojo::util::MutexLocker;
 using mojo::util::RefPtr;
+using mojo::util::StringPrintf;
 
 namespace mojo {
 namespace system {
 
 namespace {
 
 struct SerializedEndpoint {
   // This is the endpoint ID on the receiving side, and should be a "remote ID".
   // (The receiving side should already have had an endpoint attached and been
   // run via the |Channel|s. This endpoint will have both IDs assigned, so this
@@ skipping 125 matching lines @@
   // this function is still running.
   RefPtr<Channel> self(this);
 
   if (!DetachEndpointInternal(endpoint, local_id, remote_id))
     return;
 
   // Note: Send the remove message outside the lock.
   if (!SendControlMessage(MessageInTransit::Subtype::CHANNEL_REMOVE_ENDPOINT,
                           local_id, remote_id, 0, nullptr)) {
     HandleLocalError(
-        base::StringPrintf("Failed to send message to remove remote endpoint "
-                           "(local ID %u, remote ID %u)",
-                           static_cast<unsigned>(local_id.value()),
-                           static_cast<unsigned>(remote_id.value()))
+        StringPrintf("Failed to send message to remove remote endpoint (local "
+                     "ID %u, remote ID %u)",
+                     static_cast<unsigned>(local_id.value()),
+                     static_cast<unsigned>(remote_id.value()))
             .c_str());
   }
 }
 
 size_t Channel::GetSerializedEndpointSize() const {
   return sizeof(SerializedEndpoint);
 }
 
 void Channel::SerializeEndpointWithClosedPeer(
     void* destination,
@@ skipping 123 matching lines @@
 
   switch (message_view.type()) {
     case MessageInTransit::Type::ENDPOINT_CLIENT:
     case MessageInTransit::Type::ENDPOINT:
       OnReadMessageForEndpoint(message_view, std::move(platform_handles));
       break;
     case MessageInTransit::Type::CHANNEL:
       OnReadMessageForChannel(message_view, std::move(platform_handles));
       break;
     default:
-      HandleRemoteError(
-          base::StringPrintf("Received message of invalid type %u",
-                             static_cast<unsigned>(message_view.type()))
-              .c_str());
+      HandleRemoteError(StringPrintf("Received message of invalid type %u",
+                                     static_cast<unsigned>(message_view.type()))
+                            .c_str());
       break;
   }
 }
 
 void Channel::OnError(Error error) {
 #if !defined(NDEBUG) || defined(DCHECK_ALWAYS_ON)
   DCHECK(thread_checker_.IsCreationThreadCurrent());
 #endif  // !defined(NDEBUG) || defined(DCHECK_ALWAYS_ON)
 
   switch (error) {
@@ skipping 57 matching lines @@
                     "= " << local_id
                  << ", remote ID = " << message_view.source_id() << ")";
         return;
       }
 
       endpoint = it->second;
     }
   }
   if (!endpoint) {
     HandleRemoteError(
-        base::StringPrintf(
+        StringPrintf(
             "Received a message for nonexistent local destination ID %u",
-            static_cast<unsigned>(local_id.value())).c_str());
+            static_cast<unsigned>(local_id.value()))
+            .c_str());
     // 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;
   }
 
   std::unique_ptr<MessageInTransit> message(new MessageInTransit(message_view));
   if (message_view.transport_data_buffer_size() > 0) {
@@ skipping 131 matching lines @@
     endpoint = std::move(it->second);
     local_id_to_endpoint_map_.erase(it);
     // Detach and send the remove ack message outside the lock.
   }
 
   endpoint->DetachFromChannel();
 
   if (!SendControlMessage(
           MessageInTransit::Subtype::CHANNEL_REMOVE_ENDPOINT_ACK, local_id,
           remote_id, 0, nullptr)) {
-    HandleLocalError(base::StringPrintf(
-                         "Failed to send message to ack remove remote endpoint "
-                         "(local ID %u, remote ID %u)",
-                         static_cast<unsigned>(local_id.value()),
-                         static_cast<unsigned>(remote_id.value())).c_str());
+    HandleLocalError(
+        StringPrintf("Failed to send message to ack remove remote endpoint "
+                     "(local ID %u, remote ID %u)",
+                     static_cast<unsigned>(local_id.value()),
+                     static_cast<unsigned>(remote_id.value()))
+            .c_str());
   }
 
   return true;
 }
 
 bool Channel::OnRemoveEndpointAck(ChannelEndpointId local_id) {
 #if !defined(NDEBUG) || defined(DCHECK_ALWAYS_ON)
   DCHECK(thread_checker_.IsCreationThreadCurrent());
 #endif  // !defined(NDEBUG) || defined(DCHECK_ALWAYS_ON)
 
@@ skipping 50 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 (!SendControlMessage(
           MessageInTransit::Subtype::CHANNEL_ATTACH_AND_RUN_ENDPOINT, local_id,
           remote_id, 0, nullptr)) {
-    HandleLocalError(base::StringPrintf(
-                         "Failed to send message to run remote endpoint (local "
-                         "ID %u, remote ID %u)",
-                         static_cast<unsigned>(local_id.value()),
-                         static_cast<unsigned>(remote_id.value())).c_str());
+    HandleLocalError(
+        StringPrintf("Failed to send message to run remote endpoint (local "
+                     "ID %u, remote ID %u)",
+                     static_cast<unsigned>(local_id.value()),
+                     static_cast<unsigned>(remote_id.value()))
+            .c_str());
     // TODO(vtl): Should we continue on to |AttachAndRun()|?
   }
 
   endpoint->AttachAndRun(this, local_id, remote_id);
   return remote_id;
 }
 
 bool Channel::SendControlMessage(MessageInTransit::Subtype subtype,
                                  ChannelEndpointId local_id,
                                  ChannelEndpointId remote_id,
                                  uint32_t num_bytes,
                                  const void* bytes) {
   DVLOG(2) << "Sending channel control message: subtype " << subtype
            << ", local ID " << local_id << ", remote ID " << remote_id;
   std::unique_ptr<MessageInTransit> message(new MessageInTransit(
       MessageInTransit::Type::CHANNEL, subtype, num_bytes, bytes));
   message->set_source_id(local_id);
   message->set_destination_id(remote_id);
   return WriteMessage(std::move(message));
 }
 
 }  // namespace system
 }  // namespace mojo