Change mojo enums to be scoped enums in the generated C++ bindings.

chrome/browser/media/router/media_router_mojo_impl.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/media/router/media_router_mojo_impl.h"
 
 #include <stddef.h>
 #include <utility>
 
 #include "base/bind.h"
@@ skipping 23 matching lines @@
 
 using SinkAvailability = interfaces::MediaRouter::SinkAvailability;
 
 namespace {
 
 scoped_ptr<content::PresentationSessionMessage>
 ConvertToPresentationSessionMessage(interfaces::RouteMessagePtr input) {
   DCHECK(!input.is_null());
   scoped_ptr<content::PresentationSessionMessage> output;
   switch (input->type) {
-    case interfaces::RouteMessage::Type::TYPE_TEXT: {
+    case interfaces::RouteMessage::Type::TEXT: {
       DCHECK(!input->message.is_null());
       DCHECK(input->data.is_null());
       output.reset(new content::PresentationSessionMessage(
           content::PresentationMessageType::TEXT));
       input->message.Swap(&output->message);
       return output;
     }
-    case interfaces::RouteMessage::Type::TYPE_BINARY: {
+    case interfaces::RouteMessage::Type::BINARY: {
       DCHECK(!input->data.is_null());
       DCHECK(input->message.is_null());
       output.reset(new content::PresentationSessionMessage(
           content::PresentationMessageType::ARRAY_BUFFER));
       output->data.reset(new std::vector<uint8_t>);
       input->data.Swap(output->data.get());
       return output;
     }
   }
 
@@ skipping 35 matching lines @@
   // |has_local_display_route| is false. Note that ObserverList supports
   // removing an observer while iterating through it.
   router_->UpdateHasLocalDisplayRoute(has_local_display_route);
 }
 
 MediaRouterMojoImpl::MediaRouterMojoImpl(
     extensions::EventPageTracker* event_page_tracker)
     : event_page_tracker_(event_page_tracker),
       instance_id_(base::GenerateGUID()),
       has_local_display_route_(false),
-      availability_(interfaces::MediaRouter::SINK_AVAILABILITY_UNAVAILABLE),
+      availability_(interfaces::MediaRouter::SinkAvailability::UNAVAILABLE),
       wakeup_attempt_count_(0),
       current_wake_reason_(MediaRouteProviderWakeReason::TOTAL_COUNT),
       weak_factory_(this) {
   DCHECK(event_page_tracker_);
 }
 
 MediaRouterMojoImpl::~MediaRouterMojoImpl() {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   // Make sure |routes_observer_| is destroyed first, because it triggers
@@ skipping 304 matching lines @@
     new_query = true;
     sinks_query = new MediaSinksQuery;
     sinks_queries_.add(source_id, make_scoped_ptr(sinks_query));
   } else {
     DCHECK(!sinks_query->observers.HasObserver(observer));
   }
 
   // If sink availability is UNAVAILABLE, then there is no need to call MRPM.
   // |observer| can be immediately notified with an empty list.
   sinks_query->observers.AddObserver(observer);
-  if (availability_ == interfaces::MediaRouter::SINK_AVAILABILITY_UNAVAILABLE) {
+  if (availability_ == interfaces::MediaRouter::SinkAvailability::UNAVAILABLE) {
     observer->OnSinksReceived(std::vector<MediaSink>());
   } else {
     // Need to call MRPM to start observing sinks if the query is new.
     if (new_query) {
       SetWakeReason(MediaRouteProviderWakeReason::START_OBSERVING_MEDIA_SINKS);
       RunOrDefer(base::Bind(&MediaRouterMojoImpl::DoStartObservingMediaSinks,
                             base::Unretained(this), source_id));
     } else if (sinks_query->has_cached_result) {
       observer->OnSinksReceived(sinks_query->cached_sink_list);
     }
@@ skipping 14 matching lines @@
   // If we are removing the final observer for the source, then stop
   // observing sinks for it.
   // might_have_observers() is reliable here on the assumption that this call
   // is not inside the ObserverList iteration.
   sinks_query->observers.RemoveObserver(observer);
   if (!sinks_query->observers.might_have_observers()) {
     // Only ask MRPM to stop observing media sinks if the availability is not
     // UNAVAILABLE.
     // Otherwise, the MRPM would have discarded the queries already.
     if (availability_ !=
-        interfaces::MediaRouter::SINK_AVAILABILITY_UNAVAILABLE) {
+        interfaces::MediaRouter::SinkAvailability::UNAVAILABLE) {
       SetWakeReason(MediaRouteProviderWakeReason::STOP_OBSERVING_MEDIA_SINKS);
       // The |sinks_queries_| entry will be removed in the immediate or deferred
       // |DoStopObservingMediaSinks| call.
       RunOrDefer(base::Bind(&MediaRouterMojoImpl::DoStopObservingMediaSinks,
                             base::Unretained(this), source_id));
     } else {
       sinks_queries_.erase(source_id);
     }
   }
 }
@@ skipping 253 matching lines @@
     SinkAvailability availability) {
   if (!interfaces::MediaRouter::SinkAvailability_IsValidValue(availability)) {
     DLOG(WARNING) << "Unknown SinkAvailability value " << availability;
     return;
   }
 
   if (availability_ == availability)
     return;
 
   availability_ = availability;
-  if (availability_ == interfaces::MediaRouter::SINK_AVAILABILITY_UNAVAILABLE) {
+  if (availability_ == interfaces::MediaRouter::SinkAvailability::UNAVAILABLE) {
     // Sinks are no longer available. MRPM has already removed all sink queries.
     for (auto& source_and_query : sinks_queries_) {
       auto* query = source_and_query.second;
       query->is_active = false;
       query->has_cached_result = false;
       query->cached_sink_list.clear();
     }
   } else {
     // Sinks are now available. Tell MRPM to start all sink queries again.
     for (const auto& source_and_query : sinks_queries_) {
@@ skipping 17 matching lines @@
 }
 
 bool MediaRouterMojoImpl::HasLocalDisplayRoute() const {
   return has_local_display_route_;
 }
 
 void MediaRouterMojoImpl::DoStartObservingMediaSinks(
     const MediaSource::Id& source_id) {
   DVLOG_WITH_INSTANCE(1) << "DoStartObservingMediaSinks: " << source_id;
   // No need to call MRPM if there are no sinks available.
-  if (availability_ == interfaces::MediaRouter::SINK_AVAILABILITY_UNAVAILABLE)
+  if (availability_ == interfaces::MediaRouter::SinkAvailability::UNAVAILABLE)
     return;
 
   // No need to call MRPM if all observers have been removed in the meantime.
   auto* sinks_query = sinks_queries_.get(source_id);
   if (!sinks_query || !sinks_query->observers.might_have_observers())
     return;
 
   DVLOG_WITH_INSTANCE(1) << "MRPM.StartObservingMediaSinks: " << source_id;
   media_route_provider_->StartObservingMediaSinks(source_id);
   sinks_query->is_active = true;
@@ skipping 142 matching lines @@
   if (current_wake_reason_ == MediaRouteProviderWakeReason::TOTAL_COUNT)
     current_wake_reason_ = reason;
 }
 
 void MediaRouterMojoImpl::ClearWakeReason() {
   DCHECK(current_wake_reason_ != MediaRouteProviderWakeReason::TOTAL_COUNT);
   current_wake_reason_ = MediaRouteProviderWakeReason::TOTAL_COUNT;
 }
 
 }  // namespace media_router