[Media Router] Clean up issues related code.

chrome/browser/ui/webui/media_router/media_router_ui.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 "chrome/browser/ui/webui/media_router/media_router_ui.h"
 
 #include <algorithm>
 #include <string>
 #include <unordered_map>
 #include <utility>
@@ skipping 108 matching lines @@
 class MediaRouterUI::UIIssuesObserver : public IssuesObserver {
  public:
   UIIssuesObserver(MediaRouter* router, MediaRouterUI* ui)
       : IssuesObserver(router), ui_(ui) {
     DCHECK(ui);
   }
 
   ~UIIssuesObserver() override {}
 
   // IssuesObserver implementation.
-  void OnIssueUpdated(const Issue* issue) override { ui_->SetIssue(issue); }
+  void OnIssue(const Issue& issue) override { ui_->SetIssue(issue); }
+  void OnIssuesCleared() override { ui_->ClearIssue(); }
 
  private:
   // Reference back to the owning MediaRouterUI instance.
   MediaRouterUI* ui_;
 
   DISALLOW_COPY_AND_ASSIGN(UIIssuesObserver);
 };
 
 MediaRouterUI::UIMediaRoutesObserver::UIMediaRoutesObserver(
     MediaRouter* router,
@@ skipping 40 matching lines @@
   AddMediaRouterUIResources(html_source.get());
   // Ownership of |html_source| is transferred to the BrowserContext.
   content::WebUIDataSource::Add(Profile::FromWebUI(web_ui),
                                 html_source.release());
 
   // Ownership of |handler_| is transferred to |web_ui|.
   web_ui->AddMessageHandler(handler_);
 }
 
 MediaRouterUI::~MediaRouterUI() {
-  if (issues_observer_) issues_observer_->UnregisterObserver();
-
   if (query_result_manager_.get()) query_result_manager_->RemoveObserver(this);
   if (presentation_service_delegate_.get())
     presentation_service_delegate_->RemoveDefaultPresentationRequestObserver(
         this);
   // If |create_session_request_| still exists, then it means presentation route
   // request was never attempted.
   if (create_session_request_) {
     bool presentation_sinks_available = std::any_of(
         sinks_.begin(), sinks_.end(), [](const MediaSinkWithCastModes& sink) {
           return base::ContainsValue(sink.cast_modes, MediaCastMode::DEFAULT);
@@ skipping 174 matching lines @@
     delegate->GetWebDialogDelegate()->OnDialogClosed(std::string());
     delegate->OnDialogCloseFromWebUI();
   }
 }
 
 void MediaRouterUI::UIInitialized() {
   TRACE_EVENT_NESTABLE_ASYNC_END0("media_router", "UI", initiator_);
   ui_initialized_ = true;
 
   // Register for Issue updates.
-  if (!issues_observer_)
-    issues_observer_.reset(new UIIssuesObserver(router_, this));
-  issues_observer_->RegisterObserver();
+  issues_observer_.reset(new UIIssuesObserver(router_, this));
+  issues_observer_->Init();
 }
 
 bool MediaRouterUI::CreateRoute(const MediaSink::Id& sink_id,
                                 MediaCastMode cast_mode) {
   MediaSource::Id source_id;
   GURL origin;
   std::vector<MediaRouteResponseCallback> route_response_callbacks;
   base::TimeDelta timeout;
   bool incognito;
   if (!SetRouteParameters(sink_id, cast_mode, &source_id, &origin,
@@ skipping 98 matching lines @@
   }
   router_->ConnectRouteByRouteId(source_id, route_id, origin, initiator_,
                                  route_response_callbacks, timeout, incognito);
   return true;
 }
 
 void MediaRouterUI::CloseRoute(const MediaRoute::Id& route_id) {
   router_->TerminateRoute(route_id);
 }
 
-void MediaRouterUI::AddIssue(const Issue& issue) { router_->AddIssue(issue); }
+void MediaRouterUI::AddIssue(const IssueInfo& issue) {
+  router_->AddIssue(issue);
+}
 
-void MediaRouterUI::ClearIssue(const std::string& issue_id) {
+void MediaRouterUI::ClearIssue(const Issue::Id& issue_id) {
   router_->ClearIssue(issue_id);
 }
 
 void MediaRouterUI::SearchSinksAndCreateRoute(
     const MediaSink::Id& sink_id,
     const std::string& search_criteria,
     const std::string& domain,
     MediaCastMode cast_mode) {
   std::unique_ptr<MediaSource> source =
       query_result_manager_->GetSourceForCastModeAndSink(cast_mode, sink_id);
@@ skipping 42 matching lines @@
     const std::vector<MediaSinkWithCastModes>& sinks) {
   sinks_ = sinks;
 
   const icu::Collator* collator_ptr = collator_.get();
   std::sort(sinks_.begin(), sinks_.end(),
             [collator_ptr](const MediaSinkWithCastModes& sink1,
                            const MediaSinkWithCastModes& sink2) {
               return sink1.sink.CompareUsingCollator(sink2.sink, collator_ptr);
             });
 
-  if (ui_initialized_) handler_->UpdateSinks(sinks_);
+  if (ui_initialized_)
+    handler_->UpdateSinks(sinks_);
 }
 
-void MediaRouterUI::SetIssue(const Issue* issue) {
-  if (ui_initialized_) handler_->UpdateIssue(issue);
+void MediaRouterUI::SetIssue(const Issue& issue) {
+  if (ui_initialized_)
+    handler_->UpdateIssue(issue);
+}
+
+void MediaRouterUI::ClearIssue() {
+  if (ui_initialized_)
+    handler_->ClearIssue();
 }
 
 void MediaRouterUI::OnRoutesUpdated(
     const std::vector<MediaRoute>& routes,
     const std::vector<MediaRoute::Id>& joinable_route_ids) {
   routes_.clear();
   joinable_route_ids_.clear();
 
   for (const MediaRoute& route : routes) {
     if (route.for_display()) {
@@ skipping 86 matching lines @@
           IDS_MEDIA_ROUTER_ISSUE_CREATE_ROUTE_TIMEOUT_FOR_TAB);
       break;
     case DESKTOP_MIRROR:
       issue_title = l10n_util::GetStringUTF8(
           IDS_MEDIA_ROUTER_ISSUE_CREATE_ROUTE_TIMEOUT_FOR_DESKTOP);
       break;
     default:
       NOTREACHED();
   }
 
-  Issue issue(issue_title, std::string(),
-              IssueAction(IssueAction::TYPE_DISMISS),
-              std::vector<IssueAction>(), std::string(), Issue::NOTIFICATION,
-              false, -1);
-  AddIssue(issue);
+  AddIssue(IssueInfo(issue_title, IssueInfo::Action::DISMISS,
+                     IssueInfo::Severity::NOTIFICATION));
 }
 
 void MediaRouterUI::SendIssueForUnableToCast(MediaCastMode cast_mode) {
   // For a generic error, claim a tab error unless it was specifically desktop
   // mirroring.
   std::string issue_title =
       (cast_mode == MediaCastMode::DESKTOP_MIRROR)
           ? l10n_util::GetStringUTF8(
                 IDS_MEDIA_ROUTER_ISSUE_UNABLE_TO_CAST_DESKTOP)
           : l10n_util::GetStringUTF8(
                 IDS_MEDIA_ROUTER_ISSUE_CREATE_ROUTE_TIMEOUT_FOR_TAB);
-  AddIssue(Issue(issue_title, std::string(),
-                 IssueAction(IssueAction::TYPE_DISMISS),
-                 std::vector<IssueAction>(), std::string(), Issue::WARNING,
-                 false, -1));
+  AddIssue(IssueInfo(issue_title, IssueInfo::Action::DISMISS,
+                     IssueInfo::Severity::WARNING));
 }
 
 GURL MediaRouterUI::GetFrameURL() const {
   return presentation_request_ ? presentation_request_->frame_url() : GURL();
 }
 
 std::string MediaRouterUI::GetPresentationRequestSourceName() const {
   GURL gurl = GetFrameURL();
   return gurl.SchemeIs(extensions::kExtensionScheme)
              ? GetExtensionName(gurl, extensions::ExtensionRegistry::Get(
@@ skipping 40 matching lines @@
 }
 
 std::string MediaRouterUI::GetSerializedInitiatorOrigin() const {
   url::Origin origin = initiator_
                            ? url::Origin(initiator_->GetLastCommittedURL())
                            : url::Origin();
   return origin.Serialize();
 }
 
 }  // namespace media_router