[Presentation API] add 'connecting' state to WebPresentationConnectionState

third_party/WebKit/Source/modules/presentation/PresentationConnection.cpp

 // Copyright 2014 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/presentation/PresentationConnection.h"
 
 #include "bindings/core/v8/ScriptPromiseResolver.h"
 #include "core/dom/DOMArrayBuffer.h"
 #include "core/dom/DOMArrayBufferView.h"
 #include "core/dom/Document.h"
@@ skipping 28 matching lines @@
   Document* document = toDocument(executionContext);
   if (!document->frame())
     return nullptr;
   PresentationController* controller =
       PresentationController::from(*document->frame());
   return controller ? controller->client() : nullptr;
 }
 
 const AtomicString& connectionStateToString(
     WebPresentationConnectionState state) {
+  DEFINE_STATIC_LOCAL(const AtomicString, connectingValue, ("connecting"));
   DEFINE_STATIC_LOCAL(const AtomicString, connectedValue, ("connected"));
   DEFINE_STATIC_LOCAL(const AtomicString, closedValue, ("closed"));
   DEFINE_STATIC_LOCAL(const AtomicString, terminatedValue, ("terminated"));
 
   switch (state) {
+    case WebPresentationConnectionState::Connecting:
+      return connectingValue;
     case WebPresentationConnectionState::Connected:
       return connectedValue;
     case WebPresentationConnectionState::Closed:
       return closedValue;
     case WebPresentationConnectionState::Terminated:
       return terminatedValue;
   }
 
   ASSERT_NOT_REACHED();
   return terminatedValue;
@@ skipping 77 matching lines @@
   Member<PresentationConnection> m_PresentationConnection;
   std::unique_ptr<FileReaderLoader> m_loader;
 };
 
 PresentationConnection::PresentationConnection(LocalFrame* frame,
                                                const String& id,
                                                const KURL& url)
     : DOMWindowProperty(frame),
       m_id(id),
       m_url(url),
+      // TODO(zhaobin): change initial state to Connecting. (crbug/659423)
       m_state(WebPresentationConnectionState::Connected),
       m_binaryType(BinaryTypeBlob) {}
 
 PresentationConnection::~PresentationConnection() {
   ASSERT(!m_blobLoader);
 }
 
 // static
 PresentationConnection* PresentationConnection::take(
     ScriptPromiseResolver* resolver,
@@ skipping 206 matching lines @@
     }
     case BinaryTypeArrayBuffer:
       DOMArrayBuffer* buffer = DOMArrayBuffer::create(data, length);
       dispatchEvent(MessageEvent::create(buffer));
       return;
   }
   ASSERT_NOT_REACHED();
 }
 
 void PresentationConnection::close() {
-  if (m_state != WebPresentationConnectionState::Connected)
+  if (m_state != WebPresentationConnectionState::Connecting &&
+      m_state != WebPresentationConnectionState::Connected) {
     return;
+  }
   WebPresentationClient* client = presentationClient(getExecutionContext());
   if (client)
     client->closeSession(m_url, m_id);
 
   tearDown();
 }
 
 void PresentationConnection::terminate() {
   if (m_state != WebPresentationConnectionState::Connected)
     return;
@@ skipping 10 matching lines @@
          m_id == static_cast<String>(client->getId());
 }
 
 void PresentationConnection::didChangeState(
     WebPresentationConnectionState state) {
   if (m_state == state)
     return;
 
   m_state = state;
   switch (m_state) {
+    case WebPresentationConnectionState::Connecting:
+      NOTREACHED();
+      return;
     case WebPresentationConnectionState::Connected:
       dispatchEvent(Event::create(EventTypeNames::connect));
       return;
     case WebPresentationConnectionState::Terminated:
       dispatchEvent(Event::create(EventTypeNames::terminate));
       return;
     // Closed state is handled in |didClose()|.
     case WebPresentationConnectionState::Closed:
+      NOTREACHED();
       return;
   }
-  ASSERT_NOT_REACHED();
+  NOTREACHED();
 }
 
 void PresentationConnection::didClose(
     WebPresentationConnectionCloseReason reason,
     const String& message) {
   if (m_state == WebPresentationConnectionState::Closed)
     return;
 
   m_state = WebPresentationConnectionState::Closed;
   dispatchEvent(PresentationConnectionCloseEvent::create(
@@ skipping 28 matching lines @@
 void PresentationConnection::tearDown() {
   // Cancel current Blob loading if any.
   if (m_blobLoader) {
     m_blobLoader->cancel();
     m_blobLoader.clear();
   }
   m_messages.clear();
 }
 
 }  // namespace blink