AU: Handle inability to get proxy servers from Chrome better.

chrome_browser_proxy_resolver_unittest.cc

 // Copyright (c) 2011 The Chromium OS 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 <deque>
 #include <string>
 
 #include <gtest/gtest.h>
 
 #include "update_engine/chrome_browser_proxy_resolver.h"
@@ skipping 89 matching lines @@
   SendReplyArgs* args = reinterpret_cast<SendReplyArgs*>(data);
   ChromeBrowserProxyResolver::StaticFilterMessage(
       args->connection,
       args->message,
       args->resolver);
   return FALSE;  // Don't keep calling this function
 }
 
 // chrome_replies should be set to whether or not we fake a reply from
 // chrome. If there's no reply, the resolver should time out.
-void RunTest(bool chrome_replies) {
+// If chrome_alive is false, assume that sending to chrome fails.
+void RunTest(bool chrome_replies, bool chrome_alive) {
   long number = 1;
   DBusGConnection* kMockSystemGBus =
       reinterpret_cast<DBusGConnection*>(number++);
   DBusConnection* kMockSystemBus =
       reinterpret_cast<DBusConnection*>(number++);
   DBusGProxy* kMockDbusProxy =
       reinterpret_cast<DBusGProxy*>(number++);
   DBusMessage* kMockDbusMessage =
       reinterpret_cast<DBusMessage*>(number++);
 
   const char kUrl[] = "http://example.com/blah";
 
   MockDbusGlib dbus_iface;
   
   EXPECT_CALL(dbus_iface, BusGet(_, _))
-      .Times(3)
+      .Times(chrome_alive ? 3 : 2)
       .WillRepeatedly(Return(kMockSystemGBus));
   EXPECT_CALL(dbus_iface,
               ConnectionGetConnection(kMockSystemGBus))
-      .Times(2)
+      .Times(chrome_alive ? 2 : 1)
       .WillRepeatedly(Return(kMockSystemBus));
   EXPECT_CALL(dbus_iface, DbusBusAddMatch(kMockSystemBus, _, _));
   EXPECT_CALL(dbus_iface,
               DbusConnectionAddFilter(kMockSystemBus, _, _, _))
       .WillOnce(Return(1));
   EXPECT_CALL(dbus_iface,
               ProxyNewForNameOwner(kMockSystemGBus,
                                    StrEq(kLibCrosServiceName),
                                    StrEq(kLibCrosServicePath),
                                    StrEq(kLibCrosServiceInterface),
                                    _))
-      .WillOnce(Return(kMockDbusProxy));
-  EXPECT_CALL(dbus_iface, ProxyCall(
-      kMockDbusProxy,
-      StrEq(kLibCrosServiceResolveNetworkProxyMethodName),
-      _,
-      G_TYPE_STRING, StrEq(kUrl),
-      G_TYPE_STRING, StrEq(kLibCrosProxyResolveSignalInterface),
-      G_TYPE_STRING, StrEq(kLibCrosProxyResolveName),
-      G_TYPE_INVALID))
-      .WillOnce(Return(TRUE));
+      .WillOnce(Return(chrome_alive ? kMockDbusProxy : NULL));
+  if (chrome_alive)
+    EXPECT_CALL(dbus_iface, ProxyCall(
+        kMockDbusProxy,
+        StrEq(kLibCrosServiceResolveNetworkProxyMethodName),
+        _,
+        G_TYPE_STRING, StrEq(kUrl),
+        G_TYPE_STRING, StrEq(kLibCrosProxyResolveSignalInterface),
+        G_TYPE_STRING, StrEq(kLibCrosProxyResolveName),
+        G_TYPE_INVALID))
+        .WillOnce(Return(chrome_alive ? TRUE : FALSE));
   EXPECT_CALL(dbus_iface,
               DbusConnectionRemoveFilter(kMockSystemBus, _, _));
   if (chrome_replies) {
     EXPECT_CALL(dbus_iface,
                 DbusMessageIsSignal(kMockDbusMessage,
                                     kLibCrosProxyResolveSignalInterface,
                                     kLibCrosProxyResolveName))
         .WillOnce(Return(1));
     EXPECT_CALL(dbus_iface,
                 DbusMessageGetArgs(kMockDbusMessage, _,
                                    DBUS_TYPE_STRING, _,
                                    DBUS_TYPE_STRING, _,
                                    DBUS_TYPE_STRING, _,
                                    DBUS_TYPE_INVALID))
         .WillOnce(DoAll(SetArgumentPointee<3>(strdup(kUrl)),
                         SetArgumentPointee<5>(
                             strdup("SOCKS5 192.168.52.83:5555;DIRECT")),
                         Return(TRUE)));
   }
 
   GMainLoop* loop = g_main_loop_new(g_main_context_default(), FALSE);
 
   ChromeBrowserProxyResolver resolver(&dbus_iface);
-  EXPECT_TRUE(resolver.Init());
+  EXPECT_EQ(chrome_alive, resolver.Init());
   resolver.set_timeout(1);
   SendReplyArgs args = {
     kMockSystemBus,
     kMockDbusMessage,
     &resolver
   };
   if (chrome_replies)
     g_idle_add(SendReply, &args);
   EXPECT_TRUE(resolver.GetProxiesForUrl(kUrl,
                                         chrome_replies ?
                                         &DbusInterfaceTestResolved :
                                         &DbusInterfaceTestResolvedNoReply,
                                         loop));
   g_main_loop_run(loop);
   g_main_loop_unref(loop);
 }
 }  // namespace {}
 
 TEST(ChromeBrowserProxyResolverTest, SuccessTest) {
-  RunTest(true);
+  RunTest(true, true);
 }
 
 TEST(ChromeBrowserProxyResolverTest, NoReplyTest) {
-  RunTest(false);
+  RunTest(false, true);
 }
 
 TEST(ChromeBrowserProxyResolverTest, NoChromeTest) {
-  long number = 1;
-  DBusGConnection* kMockSystemGBus =
-      reinterpret_cast<DBusGConnection*>(number++);
-  DBusConnection* kMockSystemBus =
-      reinterpret_cast<DBusConnection*>(number++);
-
-  const char kUrl[] = "http://example.com/blah";
-
-  MockDbusGlib dbus_iface;
-  
-  EXPECT_CALL(dbus_iface, BusGet(_, _))
-      .Times(2)
-      .WillRepeatedly(Return(kMockSystemGBus));
-  EXPECT_CALL(dbus_iface,
-              ConnectionGetConnection(kMockSystemGBus))
-      .Times(1)
-      .WillOnce(Return(kMockSystemBus));
-  EXPECT_CALL(dbus_iface, DbusBusAddMatch(kMockSystemBus, _, _));
-  EXPECT_CALL(dbus_iface,
-              DbusConnectionAddFilter(kMockSystemBus, _, _, _))
-      .WillOnce(Return(1));
-  EXPECT_CALL(dbus_iface,
-              ProxyNewForNameOwner(kMockSystemGBus,
-                                   StrEq(kLibCrosServiceName),
-                                   StrEq(kLibCrosServicePath),
-                                   StrEq(kLibCrosServiceInterface),
-                                   _))
-      .WillOnce(Return(static_cast<DBusGProxy*>(NULL)));
-  EXPECT_CALL(dbus_iface,
-              DbusConnectionRemoveFilter(kMockSystemBus, _, _));
-  ChromeBrowserProxyResolver resolver(&dbus_iface);
-  EXPECT_FALSE(resolver.Init());
-  EXPECT_FALSE(resolver.GetProxiesForUrl(kUrl, NULL, NULL));
+  RunTest(false, false);
 }
 
 }  // namespace chromeos_update_engine