Update from https://crrev.com/308331

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 316 matching lines @@
   // Both |address| and |prefix| must be of the same type (IPv4 or IPv6).
   if (address.size() != prefix.size())
     return false;
 
   DCHECK((address.size() == 4 && prefix.size() == 4) ||
          (address.size() == 16 && prefix.size() == 16));
 
   return IPNumberMatchesPrefix(address, prefix, prefix_length_in_bits);
 }
 
+// Consider only single component domains like 'foo' as plain host names.
+bool IsPlainHostName(const std::string& hostname_utf8) {
+  if (hostname_utf8.find('.') != std::string::npos)
+    return false;
+
+  // IPv6 addresses may not contain periods, however are not be considered a
+  // plain host name.
+  IPAddressNumber unused;
+  return !ParseIPLiteralToNumber(hostname_utf8, &unused);
+}
+
 }  // namespace
 
 // ProxyResolverV8::Context ---------------------------------------------------
 
 class ProxyResolverV8::Context {
  public:
   Context(ProxyResolverV8* parent, v8::Isolate* isolate)
       : parent_(parent),
         isolate_(isolate) {
     DCHECK(isolate);
@@ skipping 85 matching lines @@
     v8::Local<v8::FunctionTemplate> my_ip_address_template =
         v8::FunctionTemplate::New(isolate_, &MyIpAddressCallback, v8_this);
     global_template->Set(ASCIILiteralToV8String(isolate_, "myIpAddress"),
                          my_ip_address_template);
 
     v8::Local<v8::FunctionTemplate> dns_resolve_template =
         v8::FunctionTemplate::New(isolate_, &DnsResolveCallback, v8_this);
     global_template->Set(ASCIILiteralToV8String(isolate_, "dnsResolve"),
                          dns_resolve_template);
 
+    v8::Local<v8::FunctionTemplate> is_plain_host_name_template =
+        v8::FunctionTemplate::New(isolate_, &IsPlainHostNameCallback, v8_this);
+    global_template->Set(ASCIILiteralToV8String(isolate_, "isPlainHostName"),
+                         is_plain_host_name_template);
+
     // Microsoft's PAC extensions:
 
     v8::Local<v8::FunctionTemplate> dns_resolve_ex_template =
         v8::FunctionTemplate::New(isolate_, &DnsResolveExCallback, v8_this);
     global_template->Set(ASCIILiteralToV8String(isolate_, "dnsResolveEx"),
                          dns_resolve_ex_template);
 
     v8::Local<v8::FunctionTemplate> my_ip_address_ex_template =
         v8::FunctionTemplate::New(isolate_, &MyIpAddressExCallback, v8_this);
     global_template->Set(ASCIILiteralToV8String(isolate_, "myIpAddressEx"),
@@ skipping 239 matching lines @@
     }
     std::string ip_prefix =
         V8StringToUTF8(v8::Local<v8::String>::Cast(args[1]));
     if (!base::IsStringASCII(ip_prefix)) {
       args.GetReturnValue().Set(false);
       return;
     }
     args.GetReturnValue().Set(IsInNetEx(ip_address, ip_prefix));
   }
 
+  // V8 callback for when "isPlainHostName()" is invoked by the PAC script.
+  static void IsPlainHostNameCallback(
+      const v8::FunctionCallbackInfo<v8::Value>& args) {
+    // Need at least 1 string arguments.
+    if (args.Length() < 1 || args[0].IsEmpty() || !args[0]->IsString()) {
+      args.GetIsolate()->ThrowException(
+          v8::Exception::TypeError(ASCIIStringToV8String(
+              args.GetIsolate(), "Requires 1 string parameter")));
+      return;
+    }
+
+    std::string hostname_utf8 =
+        V8StringToUTF8(v8::Local<v8::String>::Cast(args[0]));
+    args.GetReturnValue().Set(IsPlainHostName(hostname_utf8));
+  }
+
   mutable base::Lock lock_;
   ProxyResolverV8* parent_;
   v8::Isolate* isolate_;
   v8::Persistent<v8::External> v8_this_;
   v8::Persistent<v8::Context> v8_context_;
 };
 
 // ProxyResolverV8 ------------------------------------------------------------
 
 ProxyResolverV8::ProxyResolverV8()
@@ skipping 90 matching lines @@
     return 0;
 
   v8::Locker locked(g_proxy_resolver_isolate_->isolate());
   v8::Isolate::Scope isolate_scope(g_proxy_resolver_isolate_->isolate());
   v8::HeapStatistics heap_statistics;
   g_proxy_resolver_isolate_->isolate()->GetHeapStatistics(&heap_statistics);
   return heap_statistics.used_heap_size();
 }
 
 }  // namespace net