Display the proxy PAC javascript errors in the NetLog....

net/proxy/proxy_resolver_js_bindings_unittest.cc

 // Copyright (c) 2010 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_js_bindings.h"
+
 #include "base/scoped_ptr.h"
 #include "base/string_util.h"
 #include "net/base/address_list.h"
 #include "net/base/mock_host_resolver.h"
 #include "net/base/net_errors.h"
 #include "net/base/net_log.h"
+#include "net/base/net_log_unittest.h"
 #include "net/base/net_util.h"
 #include "net/base/sys_addrinfo.h"
-#include "net/proxy/proxy_resolver_js_bindings.h"
 #include "net/proxy/proxy_resolver_request_context.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace net {
+
 namespace {
 
 // This is a HostResolver that synchronously resolves all hosts to the
 // following address list of length 3:
 //     192.168.1.1
 //     172.22.34.1
 //     200.100.1.2
 class MockHostResolverWithMultipleResults : public HostResolver {
  public:
   // HostResolver methods:
@@ skipping 77 matching lines @@
 
  private:
   int count_;
 };
 
 TEST(ProxyResolverJSBindingsTest, DnsResolve) {
   scoped_refptr<MockHostResolver> host_resolver(new MockHostResolver);
 
   // Get a hold of a DefaultJSBindings* (it is a hidden impl class).
   scoped_ptr<ProxyResolverJSBindings> bindings(
-      ProxyResolverJSBindings::CreateDefault(host_resolver));
+      ProxyResolverJSBindings::CreateDefault(host_resolver, NULL));
 
   std::string ip_address;
 
   // Empty string is not considered a valid host (even though on some systems
   // requesting this will resolve to localhost).
   host_resolver->rules()->AddSimulatedFailure("");
   EXPECT_FALSE(bindings->DnsResolve("", &ip_address));
 
   // Should call through to the HostResolver.
   host_resolver->rules()->AddRule("google.com", "192.168.1.1");
   EXPECT_TRUE(bindings->DnsResolve("google.com", &ip_address));
   EXPECT_EQ("192.168.1.1", ip_address);
 
   // Resolve failures should give empty string.
   host_resolver->rules()->AddSimulatedFailure("fail");
   EXPECT_FALSE(bindings->DnsResolve("fail", &ip_address));
 
   // TODO(eroman): would be nice to have an IPV6 test here too, but that
   // won't work on all systems.
 }
 
 TEST(ProxyResolverJSBindingsTest, MyIpAddress) {
   // Get a hold of a DefaultJSBindings* (it is a hidden impl class).
   scoped_ptr<ProxyResolverJSBindings> bindings(
-      ProxyResolverJSBindings::CreateDefault(new MockHostResolver));
+      ProxyResolverJSBindings::CreateDefault(new MockHostResolver, NULL));
 
   // Our IP address is always going to be 127.0.0.1, since we are using a
   // mock host resolver.
   std::string my_ip_address;
   EXPECT_TRUE(bindings->MyIpAddress(&my_ip_address));
 
   EXPECT_EQ("127.0.0.1", my_ip_address);
 }
 
 // Tests that the regular PAC functions restrict results to IPv4,
 // but that the Microsoft extensions to PAC do not. We test this
 // by seeing whether ADDRESS_FAMILY_IPV4 or ADDRESS_FAMILY_UNSPECIFIED
 // was passed into to the host resolver.
 //
 //   Restricted to IPv4 address family:
 //     myIpAddress()
 //     dnsResolve()
 //
 //   Unrestricted address family:
 //     myIpAddressEx()
 //     dnsResolveEx()
 TEST(ProxyResolverJSBindingsTest, RestrictAddressFamily) {
   scoped_refptr<MockHostResolver> host_resolver(new MockHostResolver);
 
   // Get a hold of a DefaultJSBindings* (it is a hidden impl class).
   scoped_ptr<ProxyResolverJSBindings> bindings(
-      ProxyResolverJSBindings::CreateDefault(host_resolver));
+      ProxyResolverJSBindings::CreateDefault(host_resolver, NULL));
 
   // Make it so requests resolve to particular address patterns based on family:
   //  IPV4_ONLY --> 192.168.1.*
   //  UNSPECIFIED --> 192.168.2.1
   host_resolver->rules()->AddRuleForAddressFamily(
       "foo", ADDRESS_FAMILY_IPV4, "192.168.1.1");
   host_resolver->rules()->AddRuleForAddressFamily(
       "*", ADDRESS_FAMILY_IPV4, "192.168.1.2");
   host_resolver->rules()->AddRuleForAddressFamily(
       "foo", ADDRESS_FAMILY_UNSPECIFIED, "192.168.2.1");
@@ skipping 36 matching lines @@
 
 // Test that myIpAddressEx() and dnsResolveEx() both return a semi-colon
 // separated list of addresses (as opposed to the non-Ex versions which
 // just return the first result).
 TEST(ProxyResolverJSBindingsTest, ExFunctionsReturnList) {
   scoped_refptr<HostResolver> host_resolver(
       new MockHostResolverWithMultipleResults);
 
   // Get a hold of a DefaultJSBindings* (it is a hidden impl class).
   scoped_ptr<ProxyResolverJSBindings> bindings(
-      ProxyResolverJSBindings::CreateDefault(host_resolver));
+      ProxyResolverJSBindings::CreateDefault(host_resolver, NULL));
 
   std::string ip_addresses;
 
   EXPECT_TRUE(bindings->MyIpAddressEx(&ip_addresses));
   EXPECT_EQ("192.168.1.1;172.22.34.1;200.100.1.2", ip_addresses);
 
   EXPECT_TRUE(bindings->DnsResolveEx("FOO", &ip_addresses));
   EXPECT_EQ("192.168.1.1;172.22.34.1;200.100.1.2", ip_addresses);
 }
 
 TEST(ProxyResolverJSBindingsTest, PerRequestDNSCache) {
   scoped_refptr<MockFailingHostResolver> host_resolver(
       new MockFailingHostResolver);
 
   // Get a hold of a DefaultJSBindings* (it is a hidden impl class).
   scoped_ptr<ProxyResolverJSBindings> bindings(
-      ProxyResolverJSBindings::CreateDefault(host_resolver));
+      ProxyResolverJSBindings::CreateDefault(host_resolver, NULL));
 
   std::string ip_address;
 
   // Call DnsResolve() 4 times for the same hostname -- this should issue
   // 4 separate calls to the underlying host resolver, since there is no
   // current request context.
   EXPECT_FALSE(bindings->DnsResolve("foo", &ip_address));
   EXPECT_FALSE(bindings->DnsResolve("foo", &ip_address));
   EXPECT_FALSE(bindings->DnsResolve("foo", &ip_address));
   EXPECT_FALSE(bindings->DnsResolve("foo", &ip_address));
@@ skipping 22 matching lines @@
   // are different it won't reuse this particular entry.
   EXPECT_FALSE(bindings->DnsResolveEx("foo", &ip_address));
   EXPECT_EQ(1, host_resolver->count());
   EXPECT_FALSE(bindings->DnsResolveEx("foo", &ip_address));
   EXPECT_FALSE(bindings->DnsResolveEx("foo", &ip_address));
   EXPECT_EQ(1, host_resolver->count());
 
   bindings->set_current_request_context(NULL);
 }
 
+// Test that when a binding is called, it logs to the per-request NetLog.
+TEST(ProxyResolverJSBindingsTest, NetLog) {
+  scoped_refptr<MockFailingHostResolver> host_resolver(
+      new MockFailingHostResolver);
+
+  CapturingNetLog global_log(CapturingNetLog::kUnbounded);
+
+  // Get a hold of a DefaultJSBindings* (it is a hidden impl class).
+  scoped_ptr<ProxyResolverJSBindings> bindings(
+      ProxyResolverJSBindings::CreateDefault(host_resolver, &global_log));
+
+  // Attach a capturing NetLog as the current request's log stream.
+  CapturingNetLog log(CapturingNetLog::kUnbounded);
+  BoundNetLog bound_log(NetLog::Source(NetLog::SOURCE_NONE, 0), &log);
+  ProxyResolverRequestContext context(&bound_log, NULL);
+  bindings->set_current_request_context(&context);
+
+  std::string ip_address;
+
+  ASSERT_EQ(0u, log.entries().size());
+
+  // Call all the bindings. Each call should be logging something to
+  // our NetLog.
+
+  bindings->MyIpAddress(&ip_address);
+  EXPECT_EQ(2u, log.entries().size());
+  EXPECT_TRUE(LogContainsBeginEvent(
+      log.entries(), 0, NetLog::TYPE_PAC_JAVASCRIPT_MY_IP_ADDRESS));
+  EXPECT_TRUE(LogContainsEndEvent(
+      log.entries(), 1, NetLog::TYPE_PAC_JAVASCRIPT_MY_IP_ADDRESS));
+
+  bindings->MyIpAddressEx(&ip_address);
+  EXPECT_EQ(4u, log.entries().size());
+  EXPECT_TRUE(LogContainsBeginEvent(
+      log.entries(), 2, NetLog::TYPE_PAC_JAVASCRIPT_MY_IP_ADDRESS_EX));
+  EXPECT_TRUE(LogContainsEndEvent(
+      log.entries(), 3, NetLog::TYPE_PAC_JAVASCRIPT_MY_IP_ADDRESS_EX));
+
+  bindings->DnsResolve("foo", &ip_address);
+  EXPECT_EQ(6u, log.entries().size());
+  EXPECT_TRUE(LogContainsBeginEvent(
+      log.entries(), 4, NetLog::TYPE_PAC_JAVASCRIPT_DNS_RESOLVE));
+  EXPECT_TRUE(LogContainsEndEvent(
+      log.entries(), 5, NetLog::TYPE_PAC_JAVASCRIPT_DNS_RESOLVE));
+
+  bindings->DnsResolveEx("foo", &ip_address);
+  EXPECT_EQ(8u, log.entries().size());
+  EXPECT_TRUE(LogContainsBeginEvent(
+      log.entries(), 6, NetLog::TYPE_PAC_JAVASCRIPT_DNS_RESOLVE_EX));
+  EXPECT_TRUE(LogContainsEndEvent(
+      log.entries(), 7, NetLog::TYPE_PAC_JAVASCRIPT_DNS_RESOLVE_EX));
+
+  // Nothing has been emitted globally yet.
+  EXPECT_EQ(0u, global_log.entries().size());
+
+  bindings->OnError(30, string16());
+  EXPECT_EQ(9u, log.entries().size());
+  EXPECT_TRUE(LogContainsEvent(
+      log.entries(), 8, NetLog::TYPE_PAC_JAVASCRIPT_ERROR,
+      NetLog::PHASE_NONE));
+
+  // We also emit errors to the top-level log stream.
+  EXPECT_EQ(1u, global_log.entries().size());
+  EXPECT_TRUE(LogContainsEvent(
+      global_log.entries(), 0, NetLog::TYPE_PAC_JAVASCRIPT_ERROR,
+      NetLog::PHASE_NONE));
+
+  bindings->Alert(string16());
+  EXPECT_EQ(10u, log.entries().size());
+  EXPECT_TRUE(LogContainsEvent(
+      log.entries(), 9, NetLog::TYPE_PAC_JAVASCRIPT_ALERT,
+      NetLog::PHASE_NONE));
+
+  // We also emit javascript alerts to the top-level log stream.
+  EXPECT_EQ(2u, global_log.entries().size());
+  EXPECT_TRUE(LogContainsEvent(
+      global_log.entries(), 1, NetLog::TYPE_PAC_JAVASCRIPT_ALERT,
+      NetLog::PHASE_NONE));
+}
+
 }  // namespace
+
 }  // namespace net