chromeos: Add org.chromium.NetworkProxyService D-Bus service.

chromeos/dbus/services/proxy_resolution_service_provider_unittest.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 "chromeos/dbus/services/proxy_resolution_service_provider.h"
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/logging.h"
 #include "base/macros.h"
@@ skipping 178 matching lines @@
 }  // namespace
 
 class ProxyResolutionServiceProviderTest : public testing::Test {
  public:
   ProxyResolutionServiceProviderTest() : network_thread_("NetworkThread") {
     CHECK(network_thread_.Start());
 
     proxy_resolver_ =
         base::MakeUnique<TestProxyResolver>(network_thread_.task_runner());
     service_provider_ = base::MakeUnique<ProxyResolutionServiceProvider>(
+        kNetworkProxyServiceInterface, kNetworkProxyServiceResolveProxyMethod,
         base::MakeUnique<TestDelegate>(network_thread_.task_runner(),
                                        proxy_resolver_.get()));
-    test_helper_.SetUp(kLibCrosServiceName,
-                       dbus::ObjectPath(kLibCrosServicePath),
-                       kLibCrosServiceInterface, kResolveNetworkProxy,
-                       service_provider_.get());
+    test_helper_.SetUp(
+        kNetworkProxyServiceName, dbus::ObjectPath(kNetworkProxyServicePath),
+        kNetworkProxyServiceInterface, kNetworkProxyServiceResolveProxyMethod,
+        service_provider_.get());
   }
 
   ~ProxyResolutionServiceProviderTest() override {
     test_helper_.TearDown();
 
     // URLRequestContextGetter posts a task to delete itself to its task runner,
     // so give it a chance to do that.
     service_provider_.reset();
     RunPendingTasks(network_thread_.task_runner());
 
@@ skipping 30 matching lines @@
 
   // Called when connected to a signal.
   void OnConnectedToSignal(const std::string& signal_interface,
                            const std::string& signal_name,
                            bool success){
     EXPECT_EQ(kReturnSignalInterface, signal_interface);
     EXPECT_EQ(kReturnSignalName, signal_name);
     EXPECT_TRUE(success);
   }
 
-  // Makes a D-Bus call to |service_provider_|'s ResolveNetworkProxy method. If
+  // Makes a D-Bus call to |service_provider_|'s ResolveProxy method. If
   // |request_signal| is true, requests that the proxy information be returned
   // via a signal; otherwise it should be included in the response.
   // |response_out| is updated to hold the response, and |signal_out| is updated
   // to hold information about the emitted signal, if any.
   void CallMethod(const std::string& source_url,
                   bool request_signal,
                   std::unique_ptr<dbus::Response>* response_out,
                   std::unique_ptr<SignalInfo>* signal_out) {
-    dbus::MethodCall method_call(kLibCrosServiceInterface,
-                                 kResolveNetworkProxy);
+    dbus::MethodCall method_call(kNetworkProxyServiceInterface,
+                                 kNetworkProxyServiceResolveProxyMethod);
     dbus::MessageWriter writer(&method_call);
     writer.AppendString(source_url);
     if (request_signal) {
       writer.AppendString(kReturnSignalInterface);
       writer.AppendString(kReturnSignalName);
 
       // Connect to the signal that will be sent to kReturnSignalInterface and
-      // kReturnSignalName. ResolveNetworkProxy() will send the result as a
-      // signal. OnSignalReceived() will be called upon the delivery.
+      // kReturnSignalName.
       test_helper_.SetUpReturnSignal(
           kReturnSignalInterface, kReturnSignalName,
           base::Bind(&ProxyResolutionServiceProviderTest::OnSignalReceived,
                      base::Unretained(this)),
           base::Bind(&ProxyResolutionServiceProviderTest::OnConnectedToSignal,
                      base::Unretained(this)));
     }
 
     *response_out = test_helper_.CallMethod(&method_call);
 
@@ skipping 124 matching lines @@
   EXPECT_TRUE(reader.PopString(&error));
   EXPECT_EQ("DIRECT", proxy_info);
   EXPECT_EQ(net::ErrorToString(net::ERR_MANDATORY_PROXY_CONFIGURATION_FAILED),
             error);
 
   // No signal should've been emitted.
   EXPECT_FALSE(signal);
 }
 
 }  // namespace chromeos