chromeos:: Remove pointless ProxyResolverInterface.

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/macros.h"
 #include "base/memory/ptr_util.h"
 #include "base/run_loop.h"
 #include "base/single_thread_task_runner.h"
 #include "base/threading/thread_task_runner_handle.h"
 #include "chromeos/dbus/services/service_provider_test_helper.h"
 #include "dbus/message.h"
 #include "net/base/net_errors.h"
 #include "net/url_request/url_request_test_util.h"
 #include "third_party/cros_system_api/dbus/service_constants.h"
 
 namespace chromeos {
 
 namespace {
 
 // ProxyResolutionServiceProvider will return the proxy info as a D-Bus
 // signal, to the following signal interface and the signal name.
 const char kReturnSignalInterface[] = "org.chromium.TestInterface";
 const char kReturnSignalName[] = "TestSignal";
 
-// Test ProxyResolverDelegate implementation.
-class TestProxyResolverDelegate : public ProxyResolverDelegate {
+// Test ProxyResolutionServiceProvider::Delegate implementation.
+class TestDelegate : public ProxyResolutionServiceProvider::Delegate {
  public:
-  explicit TestProxyResolverDelegate(
+  explicit TestDelegate(
       const scoped_refptr<base::SingleThreadTaskRunner>& network_task_runner)
       : request_context_getter_(
             new net::TestURLRequestContextGetter(network_task_runner)) {
     // Use direct connections by default.
     proxy_info_.UseDirect();
   }
-  ~TestProxyResolverDelegate() override {}
+  ~TestDelegate() override = default;
 
   void set_async(bool async) { async_ = async; }
   void set_result(net::Error result) { result_ = result; }
 
   const net::ProxyInfo& proxy_info() const { return proxy_info_; }
   net::ProxyInfo* mutable_proxy_info() { return &proxy_info_; }
 
-  // ProxyResolverDelegate:
+  // ProxyResolutionServiceProvider::Delegate:
   scoped_refptr<net::URLRequestContextGetter> GetRequestContext() override {
     return request_context_getter_;
   }
   int ResolveProxy(net::ProxyService* proxy_service,
                    const GURL& url,
                    net::ProxyInfo* results,
                    const net::CompletionCallback& callback) override {
     EXPECT_EQ(proxy_service,
               request_context_getter_->GetURLRequestContext()->proxy_service());
     *results = proxy_info_;
@@ skipping 11 matching lines @@
   bool async_ = false;
 
   // Final result for ResolveProxy() to return.
   net::Error result_ = net::OK;
 
   // Proxy info for ResolveProxy() to return.
   net::ProxyInfo proxy_info_;
 
   scoped_refptr<net::TestURLRequestContextGetter> request_context_getter_;
 
-  DISALLOW_COPY_AND_ASSIGN(TestProxyResolverDelegate);
+  DISALLOW_COPY_AND_ASSIGN(TestDelegate);
 };
 
 }  // namespace
 
 class ProxyResolutionServiceProviderTest : public testing::Test {
  public:
   void SetUp() override {
     // Create the proxy resolution service with the mock bus and the mock
     // resolver injected.
-    delegate_ =
-        new TestProxyResolverDelegate(base::ThreadTaskRunnerHandle::Get());
-    service_provider_.reset(ProxyResolutionServiceProvider::Create(
-        std::unique_ptr<TestProxyResolverDelegate>(delegate_)));
+    delegate_ = new TestDelegate(base::ThreadTaskRunnerHandle::Get());
+    service_provider_ = base::MakeUnique<ProxyResolutionServiceProvider>(
+        std::unique_ptr<TestDelegate>(delegate_));
 
     test_helper_.SetUp(kResolveNetworkProxy, service_provider_.get());
 
     // 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.
     test_helper_.SetUpReturnSignal(
         kReturnSignalInterface,
         kReturnSignalName,
         base::Bind(&ProxyResolutionServiceProviderTest::OnSignalReceived,
@@ skipping 54 matching lines @@
 
     *response_out = test_helper_.CallMethod(&method_call);
     base::RunLoop().RunUntilIdle();
     *signal_out = std::move(signal_);
   }
 
   // Information about the last D-Bus signal received by OnSignalReceived().
   std::unique_ptr<SignalInfo> signal_;
 
   ServiceProviderTestHelper test_helper_;
-  std::unique_ptr<CrosDBusService::ServiceProviderInterface> service_provider_;
-  TestProxyResolverDelegate* delegate_;  // Owned by service_provider_.
+  std::unique_ptr<ProxyResolutionServiceProvider> service_provider_;
+  TestDelegate* delegate_;  // Owned by |service_provider_|.
 };
 
 // Tests that synchronously-resolved proxy information is returned.
 TEST_F(ProxyResolutionServiceProviderTest, ResolveProxySync) {
   const char kSourceURL[] = "http://www.gmail.com/";
 
   std::unique_ptr<dbus::Response> response;
   std::unique_ptr<SignalInfo> signal;
   CallMethod(kSourceURL, &response, &signal);
 
@@ skipping 44 matching lines @@
   EXPECT_FALSE(dbus::MessageReader(response.get()).HasMoreData());
 
   // The signal should contain an error.
   ASSERT_TRUE(signal);
   EXPECT_EQ(kSourceURL, signal->source_url);
   EXPECT_EQ(delegate_->proxy_info().ToPacString(), signal->proxy_info);
   EXPECT_EQ(net::ErrorToString(kError), signal->error_message);
 }
 
 }  // namespace chromeos