remoting: Use stl utilities from the base namespace

remoting/protocol/channel_multiplexer.cc

 // Copyright (c) 2012 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/channel_multiplexer.h"
 
 #include <stddef.h>
 #include <string.h>
 
 #include <utility>
@@ skipping 127 matching lines @@
       name_(name),
       send_id_(send_id),
       id_sent_(false),
       receive_id_(kChannelIdUnknown),
       socket_(nullptr) {
 }
 
 ChannelMultiplexer::MuxChannel::~MuxChannel() {
   // Socket must be destroyed before the channel.
   DCHECK(!socket_);
-  STLDeleteElements(&pending_packets_);
+  base::STLDeleteElements(&pending_packets_);
 }
 
 std::unique_ptr<P2PStreamSocket>
 ChannelMultiplexer::MuxChannel::CreateSocket() {
   DCHECK(!socket_);  // Can't create more than one socket per channel.
   std::unique_ptr<MuxSocket> result(new MuxSocket(this));
   socket_ = result.get();
   return std::move(result);
 }
 
@@ skipping 144 matching lines @@
 
 ChannelMultiplexer::ChannelMultiplexer(StreamChannelFactory* factory,
                                        const std::string& base_channel_name)
     : base_channel_factory_(factory),
       base_channel_name_(base_channel_name),
       next_channel_id_(0),
       weak_factory_(this) {}
 
 ChannelMultiplexer::~ChannelMultiplexer() {
   DCHECK(pending_channels_.empty());
-  STLDeleteValues(&channels_);
+  base::STLDeleteValues(&channels_);
 
   // Cancel creation of the base channel if it hasn't finished.
   if (base_channel_factory_)
     base_channel_factory_->CancelChannelCreation(base_channel_name_);
 }
 
 void ChannelMultiplexer::CreateChannel(const std::string& name,
                                        const ChannelCreatedCallback& callback) {
   if (base_channel_.get()) {
     // Already have |base_channel_|. Create new multiplexed channel
@@ skipping 133 matching lines @@
   channel->OnIncomingPacket(std::move(packet));
 }
 
 void ChannelMultiplexer::DoWrite(std::unique_ptr<MultiplexPacket> packet,
                                  const base::Closure& done_task) {
   writer_.Write(SerializeAndFrameMessage(*packet), done_task);
 }
 
 }  // namespace protocol
 }  // namespace remoting