Revert of [Presentation API] Convert presentation.mojom to new wrapper types.

content/renderer/presentation/presentation_dispatcher.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 "content/renderer/presentation/presentation_dispatcher.h"
 
 #include <algorithm>
 #include <utility>
 #include <vector>
 
@@ skipping 295 matching lines @@
 
   // Remove all pending send message requests.
   MessageRequestQueue empty;
   std::swap(message_request_queue_, empty);
 }
 
 void PresentationDispatcher::OnDestruct() {
   delete this;
 }
 
-void PresentationDispatcher::OnScreenAvailabilityUpdated(const std::string& url,
-                                                         bool available) {
-  auto status_it = availability_status_.find(url);
+void PresentationDispatcher::OnScreenAvailabilityUpdated(
+    const mojo::String& url, bool available) {
+  const std::string& availability_url = url.get();
+  auto status_it = availability_status_.find(availability_url);
   if (status_it == availability_status_.end())
     return;
   AvailabilityStatus* status = status_it->second.get();
   DCHECK(status);
 
   if (status->listening_state == ListeningState::WAITING)
     status->listening_state = ListeningState::ACTIVE;
 
   for (auto* observer : status->availability_observers)
     observer->availabilityChanged(available);
 
   for (AvailabilityCallbacksMap::iterator iter(&status->availability_callbacks);
        !iter.IsAtEnd(); iter.Advance()) {
     iter.GetCurrentValue()->onSuccess(available);
   }
   status->last_known_availability = available;
   status->availability_callbacks.Clear();
   UpdateListeningState(status);
 }
 
 void PresentationDispatcher::OnScreenAvailabilityNotSupported(
-    const std::string& url) {
-  auto status_it = availability_status_.find(url);
+    const mojo::String& url) {
+  const std::string& availability_url = url.get();
+  auto status_it = availability_status_.find(availability_url);
   if (status_it == availability_status_.end())
     return;
   AvailabilityStatus* status = status_it->second.get();
   DCHECK(status);
   DCHECK(status->listening_state == ListeningState::WAITING);
 
   const blink::WebString& not_supported_error = blink::WebString::fromUTF8(
       "getAvailability() isn't supported at the moment. It can be due to "
       "a permanent or temporary system limitation. It is recommended to "
       "try to blindly start a session in that case.");
@@ skipping 46 matching lines @@
 
   DCHECK(!connection.is_null());
   controller_->didChangeSessionState(
       new PresentationConnectionClient(std::move(connection)),
       GetWebPresentationConnectionStateFromMojo(state));
 }
 
 void PresentationDispatcher::OnConnectionClosed(
     blink::mojom::PresentationSessionInfoPtr connection,
     blink::mojom::PresentationConnectionCloseReason reason,
-    const std::string& message) {
+    const mojo::String& message) {
   if (!controller_)
     return;
 
   DCHECK(!connection.is_null());
   controller_->didCloseConnection(
       new PresentationConnectionClient(std::move(connection)),
       GetWebPresentationConnectionCloseReasonFromMojo(reason),
       blink::WebString::fromUTF8(message));
 }
 
 void PresentationDispatcher::OnSessionMessagesReceived(
     blink::mojom::PresentationSessionInfoPtr session_info,
-    std::vector<blink::mojom::SessionMessagePtr> messages) {
+    mojo::Array<blink::mojom::SessionMessagePtr> messages) {
   if (!controller_)
     return;
 
   for (size_t i = 0; i < messages.size(); ++i) {
     // Note: Passing batches of messages to the Blink layer would be more
     // efficient.
     std::unique_ptr<PresentationConnectionClient> session_client(
         new PresentationConnectionClient(session_info->url, session_info->id));
     switch (messages[i]->type) {
       case blink::mojom::PresentationMessageType::TEXT: {
-        // TODO(mfoltz): Do we need to DCHECK(messages[i]->message)?
         controller_->didReceiveSessionTextMessage(
             session_client.release(),
-            blink::WebString::fromUTF8(messages[i]->message.value()));
+            blink::WebString::fromUTF8(messages[i]->message));
         break;
       }
       case blink::mojom::PresentationMessageType::ARRAY_BUFFER:
       case blink::mojom::PresentationMessageType::BLOB: {
-        // TODO(mfoltz): Do we need to DCHECK(messages[i]->data)?
         controller_->didReceiveSessionBinaryMessage(
-            session_client.release(), &(messages[i]->data->front()),
-            messages[i]->data->size());
+            session_client.release(), &(messages[i]->data.front()),
+            messages[i]->data.size());
         break;
       }
       default: {
         NOTREACHED();
         break;
       }
     }
   }
 }
 
@@ skipping 58 matching lines @@
     const uint8_t* data,
     size_t length) {
   blink::mojom::PresentationSessionInfoPtr session_info =
       blink::mojom::PresentationSessionInfo::New();
   session_info->url = presentationUrl.utf8();
   session_info->id = presentationId.utf8();
 
   blink::mojom::SessionMessagePtr session_message =
       blink::mojom::SessionMessage::New();
   session_message->type = type;
-  session_message->data = std::vector<uint8_t>(data, data + length);
+  std::vector<uint8_t> tmp_data_vector(data, data + length);
+  session_message->data.Swap(&tmp_data_vector);
   return new SendMessageRequest(std::move(session_info),
                                 std::move(session_message));
 }
 
 PresentationDispatcher::AvailabilityStatus::AvailabilityStatus(
     const std::string& availability_url)
     : url(availability_url),
       last_known_availability(false),
       listening_state(ListeningState::INACTIVE) {}
 
 PresentationDispatcher::AvailabilityStatus::~AvailabilityStatus() {
 }
 
 }  // namespace content