Update monet.

net/websockets/websocket_basic_handshake_stream.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 "net/websockets/websocket_basic_handshake_stream.h"
 
 #include <algorithm>
 #include <iterator>
 #include <set>
 #include <string>
@@ skipping 81 matching lines @@
   std::string encoded_challenge;
   base::Base64Encode(raw_challenge, &encoded_challenge);
   return encoded_challenge;
 }
 
 void AddVectorHeaderIfNonEmpty(const char* name,
                                const std::vector<std::string>& value,
                                HttpRequestHeaders* headers) {
   if (value.empty())
     return;
-  headers->SetHeader(name, JoinString(value, ", "));
+  headers->SetHeader(name, base::JoinString(value, ", "));
 }
 
 GetHeaderResult GetSingleHeaderValue(const HttpResponseHeaders* headers,
                                      const base::StringPiece& name,
                                      std::string* value) {
   void* state = nullptr;
   size_t num_values = 0;
   std::string temp_value;
   while (headers->EnumerateHeader(&state, name, &temp_value)) {
     if (++num_values > 1)
@@ skipping 22 matching lines @@
                      std::string* failure_message) {
   std::string value;
   GetHeaderResult result =
       GetSingleHeaderValue(headers, websockets::kUpgrade, &value);
   if (!ValidateHeaderHasSingleValue(result,
                                     websockets::kUpgrade,
                                     failure_message)) {
     return false;
   }
 
-  if (!LowerCaseEqualsASCII(value, websockets::kWebSocketLowercase)) {
+  if (!base::LowerCaseEqualsASCII(value, websockets::kWebSocketLowercase)) {
     *failure_message =
         "'Upgrade' header value is not 'WebSocket': " + value;
     return false;
   }
   return true;
 }
 
 bool ValidateSecWebSocketAccept(const HttpResponseHeaders* headers,
                                 const std::string& expected,
                                 std::string* failure_message) {
@@ skipping 183 matching lines @@
         }
         header_values.push_back(header_value);
       } else {
         *failure_message = "Found an unsupported extension '" +
                            extension.name() +
                            "' in 'Sec-WebSocket-Extensions' header";
         return false;
       }
     }
   }
-  *accepted_extensions_descriptor = JoinString(header_values, ", ");
+  *accepted_extensions_descriptor = base::JoinString(header_values, ", ");
   return true;
 }
 
 }  // namespace
 
 WebSocketBasicHandshakeStream::WebSocketBasicHandshakeStream(
     scoped_ptr<ClientSocketHandle> connection,
     WebSocketStream::ConnectDelegate* connect_delegate,
     bool using_proxy,
     std::vector<std::string> requested_sub_protocols,
@@ skipping 287 matching lines @@
   set_failure_message("Error during WebSocket handshake: " + failure_message);
   return ERR_INVALID_RESPONSE;
 }
 
 void WebSocketBasicHandshakeStream::set_failure_message(
     const std::string& failure_message) {
   *failure_message_ = failure_message;
 }
 
 }  // namespace net