Add support for ProxyResolverErrorObserver to ProxyResolverMojo.

net/proxy/proxy_resolver_error_observer_mojo_unittest.cc

+// Copyright 2015 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_error_observer_mojo.h"
+
+#include <utility>
+#include <vector>
+
+#include "base/bind.h"
+#include "base/strings/utf_string_conversions.h"
+#include "base/threading/thread.h"
+#include "mojo/common/common_type_converters.h"
+#include "net/test/event_waiter.h"
+#include "testing/gtest/include/gtest/gtest.h"
+
+namespace net {
+namespace {
+
+class ErrorObserverClient : public interfaces::ProxyResolverErrorObserver {
+ public:
+  enum Event {
+    ERROR_RECEIVED,
+  };
+
+  explicit ErrorObserverClient(
+      mojo::InterfaceRequest<interfaces::ProxyResolverErrorObserver> request);
+
+  EventWaiter<Event>& event_waiter() { return event_waiter_; }
+  const std::vector<std::pair<int, base::string16>>& errors() const {
+    return errors_;
+  }
+
+ private:
+  void OnPacScriptError(int32_t line_number,
+                        const mojo::String& error) override;
+
+  mojo::Binding<interfaces::ProxyResolverErrorObserver> binding_;
+  EventWaiter<Event> event_waiter_;
+  std::vector<std::pair<int, base::string16>> errors_;
+
+  DISALLOW_COPY_AND_ASSIGN(ErrorObserverClient);
+};
+
+ErrorObserverClient::ErrorObserverClient(
+    mojo::InterfaceRequest<interfaces::ProxyResolverErrorObserver> request)
+    : binding_(this, request.Pass()) {
+}
+
+void ErrorObserverClient::OnPacScriptError(int32_t line_number,
+                                           const mojo::String& error) {
+  errors_.push_back(std::make_pair(line_number, error.To<base::string16>()));
+  event_waiter_.NotifyEvent(ERROR_RECEIVED);
+}
+
+}  // namespace
+
+class ProxyResolverErrorObserverMojoTest : public testing::Test {
+ public:
+  ProxyResolverErrorObserver& error_observer() { return *error_observer_; }
+  ErrorObserverClient& client() { return *client_; }
+
+ private:
+  void SetUp() override {
+    interfaces::ProxyResolverErrorObserverPtr error_observer_ptr;
+    client_.reset(new ErrorObserverClient(mojo::GetProxy(&error_observer_ptr)));
+    error_observer_ =
+        ProxyResolverErrorObserverMojo::Create(error_observer_ptr.Pass());
+    ASSERT_TRUE(error_observer_);
+  }
+
+  scoped_ptr<ErrorObserverClient> client_;
+  scoped_ptr<ProxyResolverErrorObserver> error_observer_;
+};
+
+TEST_F(ProxyResolverErrorObserverMojoTest, NullHandle) {
+  EXPECT_FALSE(ProxyResolverErrorObserverMojo::Create(
+      interfaces::ProxyResolverErrorObserverPtr()));
+}
+
+TEST_F(ProxyResolverErrorObserverMojoTest, ErrorReportedOnMainThread) {
+  base::string16 error(base::ASCIIToUTF16("error message"));
+  error_observer().OnPACScriptError(123, error);
+  client().event_waiter().WaitForEvent(ErrorObserverClient::ERROR_RECEIVED);
+  ASSERT_EQ(1u, client().errors().size());
+  EXPECT_EQ(123, client().errors()[0].first);
+  EXPECT_EQ(error, client().errors()[0].second);
+}
+
+TEST_F(ProxyResolverErrorObserverMojoTest, ErrorReportedOnAnotherThread) {
+  base::Thread other_thread("error reporting thread");
+  base::string16 error(base::ASCIIToUTF16("error message"));
+  other_thread.Start();
+  other_thread.message_loop()->PostTask(
+      FROM_HERE, base::Bind(&ProxyResolverErrorObserver::OnPACScriptError,
+                            base::Unretained(&error_observer()), 123, error));
+  client().event_waiter().WaitForEvent(ErrorObserverClient::ERROR_RECEIVED);
+  ASSERT_EQ(1u, client().errors().size());
+  EXPECT_EQ(123, client().errors()[0].first);
+  EXPECT_EQ(error, client().errors()[0].second);
+}
+
+}  // namespace net