[MediaRouter]Wires up issue manager in MediaRouterMojoImpl.

chrome/browser/media/router/media_router_mojo_impl_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 <string>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/run_loop.h"
 #include "base/synchronization/waitable_event.h"
+#include "chrome/browser/media/router/issue.h"
 #include "chrome/browser/media/router/media_route.h"
 #include "chrome/browser/media/router/media_router_mojo_test.h"
+#include "chrome/browser/media/router/media_router_type_converters.h"
 #include "chrome/browser/media/router/mock_media_router.h"
 #include "chrome/browser/media/router/test_helper.h"
 #include "chrome/test/base/chrome_render_view_host_test_harness.h"
 #include "chrome/test/base/testing_profile.h"
 #include "extensions/browser/extension_registry.h"
 #include "extensions/browser/process_manager.h"
 #include "extensions/browser/process_manager_factory.h"
 #include "media/base/gmock_callback_support.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 using testing::_;
 using testing::Eq;
 using testing::Invoke;
+using testing::Mock;
 using testing::Pointee;
 using testing::Return;
 using testing::ReturnRef;
 using testing::SaveArg;
 
 namespace media_router {
 
 namespace {
 
 const char kDescription[] = "description";
@@ skipping 16 matching lines @@
     const content::PresentationSessionMessage* actual) {
   if (expected->presentation_url != actual->presentation_url ||
       expected->presentation_id != actual->presentation_id ||
       expected->type != actual->type) {
     return false;
   }
   return expected->is_binary() ? *(expected->data) == *(actual->data)
                                : *(expected->message) == *(actual->message);
 }
 
+interfaces::IssuePtr CreateMojoIssue(const std::string& title) {
+  interfaces::IssuePtr mojoIssue = interfaces::Issue::New();
+  mojoIssue->title = title;
+  mojoIssue->message = "msg";
+  mojoIssue->route_id = "";
+  mojoIssue->default_action = interfaces::Issue::ActionType::ACTION_TYPE_OK;
+  mojoIssue->secondary_actions =
+      mojo::Array<interfaces::Issue::ActionType>::New(0);
+  mojoIssue->severity = interfaces::Issue::Severity::SEVERITY_WARNING;
+  mojoIssue->is_blocking = false;
+  mojoIssue->help_url = "";
+  return mojoIssue.Pass();
+}
+
 }  // namespace
 
 class RouteResponseCallbackHandler {
  public:
   MOCK_METHOD2(Invoke,
                void(const MediaRoute* route, const std::string& error_text));
 };
 
 class SendMessageCallbackHandler {
  public:
@@ skipping 177 matching lines @@
                       route_response_callbacks);
   ProcessEventLoop();
 }
 
 TEST_F(MediaRouterMojoImplTest, CloseRoute) {
   EXPECT_CALL(mock_media_route_provider_, CloseRoute(mojo::String(kRouteId)));
   router()->CloseRoute(kRouteId);
   ProcessEventLoop();
 }
 
+TEST_F(MediaRouterMojoImplTest, HandleIssue) {
+  MockIssuesObserver issue_observer1(router());
+  MockIssuesObserver issue_observer2(router());
+  interfaces::IssuePtr mojo_issue1 = CreateMojoIssue("title 1");
+  const Issue& expected_issue1 = mojo_issue1.To<Issue>();
+
+  const Issue* issue;
+  EXPECT_CALL(issue_observer1,
+              OnIssueUpdated(Pointee(EqualsIssue(expected_issue1))))
+      .WillOnce(SaveArg<0>(&issue));
+  EXPECT_CALL(issue_observer2,
+              OnIssueUpdated(Pointee(EqualsIssue(expected_issue1))));
+  media_router_proxy_->OnIssue(mojo_issue1.Pass());
+  ProcessEventLoop();
+
+  EXPECT_TRUE(Mock::VerifyAndClearExpectations(&issue_observer1));
+  EXPECT_TRUE(Mock::VerifyAndClearExpectations(&issue_observer2));
+
+  router()->ClearIssue(issue->id());
+  router()->UnregisterIssuesObserver(&issue_observer1);
+  interfaces::IssuePtr mojo_issue2 = CreateMojoIssue("title 2");
+  const Issue& expected_issue2 = mojo_issue2.To<Issue>();
+
+  EXPECT_CALL(issue_observer2,
+              OnIssueUpdated(Pointee(EqualsIssue(expected_issue2))));
+  media_router_proxy_->OnIssue(mojo_issue2.Pass());
+  ProcessEventLoop();
+}
+
 TEST_F(MediaRouterMojoImplTest, RegisterAndUnregisterMediaSinksObserver) {
   MediaSource media_source(kSource);
 
   MockMediaRouter mock_router;
   EXPECT_CALL(mock_media_route_provider_,
               StartObservingMediaSinks(mojo::String(kSource))).Times(2);
   EXPECT_CALL(mock_media_route_provider_,
               StartObservingMediaSinks(mojo::String(kSource2)));
 
   MediaSinksObserver* captured_observer;
@@ skipping 246 matching lines @@
   binding.reset(new mojo::Binding<interfaces::MediaRouteProvider>(
       &mock_media_route_provider, mojo::GetProxy(&media_route_provider_proxy)));
   media_router_proxy->RegisterMediaRouteProvider(
       media_route_provider_proxy.Pass(),
       base::Bind(&RegisterMediaRouteProviderHandler::Invoke,
                  base::Unretained(&provide_handler)));
   message_loop.RunUntilIdle();
 }
 
 }  // namespace media_router