[Blink, RemotePlayback]Split onstatechange to separate events

third_party/WebKit/Source/modules/remoteplayback/RemotePlayback.cpp

 // Copyright 2016 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 "modules/remoteplayback/RemotePlayback.h"
 
 #include "bindings/core/v8/ScriptPromiseResolver.h"
 #include "bindings/modules/v8/RemotePlaybackAvailabilityCallback.h"
 #include "core/HTMLNames.h"
 #include "core/dom/DOMException.h"
 #include "core/dom/Document.h"
 #include "core/dom/ExecutionContextTask.h"
 #include "core/events/Event.h"
 #include "core/html/HTMLMediaElement.h"
 #include "modules/EventTargetModules.h"
 #include "platform/UserGestureIndicator.h"
 
 namespace blink {
 
 namespace {
 
 const AtomicString& remotePlaybackStateToString(WebRemotePlaybackState state) {
+  DEFINE_STATIC_LOCAL(const AtomicString, connectingValue, ("connecting"));
   DEFINE_STATIC_LOCAL(const AtomicString, connectedValue, ("connected"));
   DEFINE_STATIC_LOCAL(const AtomicString, disconnectedValue, ("disconnected"));
 
   switch (state) {
+    case WebRemotePlaybackState::Connecting:
+      return connectingValue;
     case WebRemotePlaybackState::Connected:
       return connectedValue;
     case WebRemotePlaybackState::Disconnected:
       return disconnectedValue;
   }
 
   ASSERT_NOT_REACHED();
   return disconnectedValue;
 }
 
@@ skipping 174 matching lines @@
     else
       m_promptPromiseResolver->reject(DOMException::create(
           AbortError, "Failed to connect to the remote device."));
     m_promptPromiseResolver = nullptr;
   }
 
   if (m_state == state)
     return;
 
   m_state = state;
-  dispatchEvent(Event::create(EventTypeNames::statechange));
+  switch (m_state) {
+    case WebRemotePlaybackState::Connecting:
+      dispatchEvent(Event::create(EventTypeNames::connecting));
+      break;
+    case WebRemotePlaybackState::Connected:
+      dispatchEvent(Event::create(EventTypeNames::connect));
+      break;
+    case WebRemotePlaybackState::Disconnected:
+      dispatchEvent(Event::create(EventTypeNames::disconnect));
+      break;
+  }
 }
 
 void RemotePlayback::availabilityChanged(bool available) {
   if (m_availability == available)
     return;
 
   m_availability = available;
   for (auto& callback : m_availabilityCallbacks.values())
     callback->call(m_scriptState.get(), this, m_availability);
 }
 
 void RemotePlayback::promptCancelled() {
   if (!m_promptPromiseResolver)
     return;
 
   m_promptPromiseResolver->reject(
       DOMException::create(NotAllowedError, "The prompt was dismissed."));
   m_promptPromiseResolver = nullptr;
 }
 
 DEFINE_TRACE(RemotePlayback) {
   visitor->trace(m_availabilityCallbacks);
   visitor->trace(m_promptPromiseResolver);
   visitor->trace(m_mediaElement);
   EventTargetWithInlineData::trace(visitor);
 }
 
 }  // namespace blink