Move IsStringASCII/UTF8 to base namespace.

net/proxy/proxy_resolver_v8.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 "net/proxy/proxy_resolver_v8.h"
 
 #include <algorithm>
 #include <cstdio>
 
 #include "base/basictypes.h"
@@ skipping 92 matching lines @@
   DISALLOW_COPY_AND_ASSIGN(V8ExternalStringFromScriptData);
 };
 
 // External string wrapper so V8 can access a string literal.
 class V8ExternalASCIILiteral : public v8::String::ExternalAsciiStringResource {
  public:
   // |ascii| must be a NULL-terminated C string, and must remain valid
   // throughout this object's lifetime.
   V8ExternalASCIILiteral(const char* ascii, size_t length)
       : ascii_(ascii), length_(length) {
-    DCHECK(IsStringASCII(ascii));
+    DCHECK(base::IsStringASCII(ascii));
   }
 
   virtual const char* data() const OVERRIDE {
     return ascii_;
   }
 
   virtual size_t length() const OVERRIDE {
     return length_;
   }
 
@@ skipping 26 matching lines @@
   // Note that the reinterpret cast is because on Windows string16 is an alias
   // to wstring, and hence has character type wchar_t not uint16_t.
   if (len > 0)
     s->Write(reinterpret_cast<uint16_t*>(WriteInto(&result, len + 1)), 0, len);
   return result;
 }
 
 // Converts an ASCII std::string to a V8 string.
 v8::Local<v8::String> ASCIIStringToV8String(v8::Isolate* isolate,
                                             const std::string& s) {
-  DCHECK(IsStringASCII(s));
+  DCHECK(base::IsStringASCII(s));
   return v8::String::NewFromUtf8(isolate, s.data(), v8::String::kNormalString,
                                  s.size());
 }
 
 // Converts a UTF16 base::string16 (warpped by a ProxyResolverScriptData) to a
 // V8 string.
 v8::Local<v8::String> ScriptDataToV8String(
     v8::Isolate* isolate, const scoped_refptr<ProxyResolverScriptData>& s) {
   if (s->utf16().size() * 2 <= kMaxStringBytesForCopy) {
     return v8::String::NewFromTwoByte(
         isolate,
         reinterpret_cast<const uint16_t*>(s->utf16().data()),
         v8::String::kNormalString,
         s->utf16().size());
   }
   return v8::String::NewExternal(isolate,
                                  new V8ExternalStringFromScriptData(s));
 }
 
 // Converts an ASCII string literal to a V8 string.
 v8::Local<v8::String> ASCIILiteralToV8String(v8::Isolate* isolate,
                                              const char* ascii) {
-  DCHECK(IsStringASCII(ascii));
+  DCHECK(base::IsStringASCII(ascii));
   size_t length = strlen(ascii);
   if (length <= kMaxStringBytesForCopy)
     return v8::String::NewFromUtf8(isolate, ascii, v8::String::kNormalString,
                                    length);
   return v8::String::NewExternal(isolate,
                                  new V8ExternalASCIILiteral(ascii, length));
 }
 
 // Stringizes a V8 object by calling its toString() method. Returns true
 // on success. This may fail if the toString() throws an exception.
@@ skipping 15 matching lines @@
 // and fills |*hostname| with the result.
 bool GetHostnameArgument(const v8::FunctionCallbackInfo<v8::Value>& args,
                          std::string* hostname) {
   // The first argument should be a string.
   if (args.Length() == 0 || args[0].IsEmpty() || !args[0]->IsString())
     return false;
 
   const base::string16 hostname_utf16 = V8StringToUTF16(args[0]->ToString());
 
   // If the hostname is already in ASCII, simply return it as is.
-  if (IsStringASCII(hostname_utf16)) {
+  if (base::IsStringASCII(hostname_utf16)) {
     *hostname = base::UTF16ToASCII(hostname_utf16);
     return true;
   }
 
   // Otherwise try to convert it from IDN to punycode.
   const int kInitialBufferSize = 256;
   url_canon::RawCanonOutputT<base::char16, kInitialBufferSize> punycode_output;
   if (!url_canon::IDNToASCII(hostname_utf16.data(),
                              hostname_utf16.length(),
                              &punycode_output)) {
     return false;
   }
 
   // |punycode_output| should now be ASCII; convert it to a std::string.
   // (We could use UTF16ToASCII() instead, but that requires an extra string
   // copy. Since ASCII is a subset of UTF8 the following is equivalent).
   bool success = base::UTF16ToUTF8(punycode_output.data(),
                              punycode_output.length(),
                              hostname);
   DCHECK(success);
-  DCHECK(IsStringASCII(*hostname));
+  DCHECK(base::IsStringASCII(*hostname));
   return success;
 }
 
 // Wrapper for passing around IP address strings and IPAddressNumber objects.
 struct IPAddress {
   IPAddress(const std::string& ip_string, const IPAddressNumber& ip_number)
       : string_value(ip_string),
         ip_address_number(ip_number) {
   }
 
@@ skipping 140 matching lines @@
     }
 
     if (!ret->IsString()) {
       js_bindings()->OnError(
           -1, base::ASCIIToUTF16("FindProxyForURL() did not return a string."));
       return ERR_PAC_SCRIPT_FAILED;
     }
 
     base::string16 ret_str = V8StringToUTF16(ret->ToString());
 
-    if (!IsStringASCII(ret_str)) {
+    if (!base::IsStringASCII(ret_str)) {
       // TODO(eroman): Rather than failing when a wide string is returned, we
       //               could extend the parsing to handle IDNA hostnames by
       //               converting them to ASCII punycode.
       //               crbug.com/47234
       base::string16 error_message =
           base::ASCIIToUTF16("FindProxyForURL() returned a non-ASCII string "
                              "(crbug.com/47234): ") + ret_str;
       js_bindings()->OnError(-1, error_message);
       return ERR_PAC_SCRIPT_FAILED;
     }
@@ skipping 241 matching lines @@
   // V8 callback for when "sortIpAddressList()" is invoked by the PAC script.
   static void SortIpAddressListCallback(
       const v8::FunctionCallbackInfo<v8::Value>& args) {
     // We need at least one string argument.
     if (args.Length() == 0 || args[0].IsEmpty() || !args[0]->IsString()) {
       args.GetReturnValue().SetNull();
       return;
     }
 
     std::string ip_address_list = V8StringToUTF8(args[0]->ToString());
-    if (!IsStringASCII(ip_address_list)) {
+    if (!base::IsStringASCII(ip_address_list)) {
       args.GetReturnValue().SetNull();
       return;
     }
     std::string sorted_ip_address_list;
     bool success = SortIpAddressList(ip_address_list, &sorted_ip_address_list);
     if (!success) {
       args.GetReturnValue().Set(false);
       return;
     }
     args.GetReturnValue().Set(
         ASCIIStringToV8String(args.GetIsolate(), sorted_ip_address_list));
   }
 
   // V8 callback for when "isInNetEx()" is invoked by the PAC script.
   static void IsInNetExCallback(
       const v8::FunctionCallbackInfo<v8::Value>& args) {
     // We need at least 2 string arguments.
     if (args.Length() < 2 || args[0].IsEmpty() || !args[0]->IsString() ||
         args[1].IsEmpty() || !args[1]->IsString()) {
       args.GetReturnValue().SetNull();
       return;
     }
 
     std::string ip_address = V8StringToUTF8(args[0]->ToString());
-    if (!IsStringASCII(ip_address)) {
+    if (!base::IsStringASCII(ip_address)) {
       args.GetReturnValue().Set(false);
       return;
     }
     std::string ip_prefix = V8StringToUTF8(args[1]->ToString());
-    if (!IsStringASCII(ip_prefix)) {
+    if (!base::IsStringASCII(ip_prefix)) {
       args.GetReturnValue().Set(false);
       return;
     }
     args.GetReturnValue().Set(IsInNetEx(ip_address, ip_prefix));
   }
 
   mutable base::Lock lock_;
   ProxyResolverV8* parent_;
   v8::Isolate* isolate_;
   v8::Persistent<v8::External> v8_this_;
@@ skipping 110 matching lines @@
     return 0;
 
   v8::Locker locked(g_default_isolate_);
   v8::Isolate::Scope isolate_scope(g_default_isolate_);
   v8::HeapStatistics heap_statistics;
   g_default_isolate_->GetHeapStatistics(&heap_statistics);
   return heap_statistics.used_heap_size();
 }
 
 }  // namespace net