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

Revert of [Presentation API] Convert presentation.mojom to new wrapper types. (patchset #5 id:80001 of https://codereview.chromium.org/2181163003/ )

Reason for revert:
Suspect (not the first) for widespread NaCl test failures since
https://build.chromium.org/p/chromium.win/builders/Win7%20Tests%20%281%29/builds/55504

Errors like

[4224:3200:0729/162247:ERROR:nacl_process_host.cc(337)] NaCl process exited with status -1073741674 (0xc0000096)
...
  Actual: "Plugin crashed. 'NaCl module crashed'"

Wasn't r408782 or r408787. Running out of candidates..

Original issue's description:
> [Presentation API] Convert presentation.mojom to new wrapper types.
>
> This converts presentation.mojom to use the new (std::) Mojo wrapper types:
> mojo::String => std::string
> mojo::Array => std::vector
>
> No behavior changes should ensue.
>
> Optional values are represented as base::Optional<Foo> with the new wrapper
> types requiring some additional changes.
>
> This work will simplify further changes for crbug.com/627655.
>
> BUG=627655
>
> Committed: https://crrev.com/59e7b40948030815a49af887b922b370ba048b8b
> Cr-Commit-Position: refs/heads/master@{#408781}

TBR=dcheng@chromium.org,imcheng@chromium.org,mfoltz@chromium.org
NOTRY=true
BUG=627655

Review-Url: https://codereview.chromium.org/2196143002
Cr-Commit-Position: refs/heads/master@{#408905}

content/browser/presentation/presentation_service_impl.cc

@@ -49,15 +49,15 @@ blink::mojom::SessionMessagePtr ToMojoSessionMessage(
     DCHECK(input->data);
     output->type = blink::mojom::PresentationMessageType::ARRAY_BUFFER;
     if (pass_ownership) {
-      output->data = std::move(*(input->data));
+      output->data.Swap(input->data.get());
     } else {
-      output->data = *(input->data);
+      output->data = mojo::Array<uint8_t>::From(*input->data);
     }
   } else {
     // string message
     output->type = blink::mojom::PresentationMessageType::TEXT;
     if (pass_ownership) {
-      output->message = std::move(input->message);
+      output->message.Swap(&input->message);
     } else {
       output->message = input->message;
     }
@@ -67,47 +67,43 @@ blink::mojom::SessionMessagePtr ToMojoSessionMessage(
 
 std::unique_ptr<PresentationSessionMessage> GetPresentationSessionMessage(
     blink::mojom::SessionMessagePtr input) {
+  DCHECK(!input.is_null());
   std::unique_ptr<content::PresentationSessionMessage> output;
-  if (input.is_null())
-    return output;
-
   switch (input->type) {
     case blink::mojom::PresentationMessageType::TEXT: {
-      // Return nullptr PresentationSessionMessage if invalid (unset |message|,
-      // set |data|, or size too large).
-      if (input->data || !input->message ||
-          input->message->size() > content::kMaxPresentationSessionMessageSize)
+      DCHECK(!input->message.is_null());
+      DCHECK(input->data.is_null());
+      // Return null PresentationSessionMessage if size exceeds.
+      if (input->message.size() > content::kMaxPresentationSessionMessageSize)
         return output;
 
       output.reset(
           new PresentationSessionMessage(PresentationMessageType::TEXT));
-      output->message = std::move(input->message.value());
+      input->message.Swap(&output->message);
       return output;
     }
     case blink::mojom::PresentationMessageType::ARRAY_BUFFER: {
-      // Return nullptr PresentationSessionMessage if invalid (unset |data|, set
-      // |message|, or size too large).
-      if (!input->data || input->message ||
-          input->data->size() > content::kMaxPresentationSessionMessageSize)
+      DCHECK(!input->data.is_null());
+      DCHECK(input->message.is_null());
+      if (input->data.size() > content::kMaxPresentationSessionMessageSize)
         return output;
 
       output.reset(new PresentationSessionMessage(
           PresentationMessageType::ARRAY_BUFFER));
-      output->data.reset(
-          new std::vector<uint8_t>(std::move(input->data.value())));
+      output->data.reset(new std::vector<uint8_t>);
+      input->data.Swap(output->data.get());
       return output;
     }
     case blink::mojom::PresentationMessageType::BLOB: {
-      // Return nullptr PresentationSessionMessage if invalid (unset |data|, set
-      // |message|, or size too large).
-      if (!input->data || input->message ||
-          input->data->size() > content::kMaxPresentationSessionMessageSize)
+      DCHECK(!input->data.is_null());
+      DCHECK(input->message.is_null());
+      if (input->data.size() > content::kMaxPresentationSessionMessageSize)
         return output;
 
       output.reset(
           new PresentationSessionMessage(PresentationMessageType::BLOB));
-      output->data.reset(
-          new std::vector<uint8_t>(std::move(input->data.value())));
+      output->data.reset(new std::vector<uint8_t>);
+      input->data.Swap(output->data.get());
       return output;
     }
   }
@@ -183,35 +179,37 @@ void PresentationServiceImpl::SetClient(
 }
 
 void PresentationServiceImpl::ListenForScreenAvailability(
-    const std::string& url) {
+      const mojo::String& url) {
   DVLOG(2) << "ListenForScreenAvailability " << url;
   if (!delegate_) {
     client_->OnScreenAvailabilityUpdated(url, false);
     return;
   }
 
-  if (screen_availability_listeners_.count(url))
+  const std::string& availability_url = url.get();
+  if (screen_availability_listeners_.count(availability_url))
     return;
 
   std::unique_ptr<ScreenAvailabilityListenerImpl> listener(
-      new ScreenAvailabilityListenerImpl(url, this));
+      new ScreenAvailabilityListenerImpl(availability_url, this));
   if (delegate_->AddScreenAvailabilityListener(
       render_process_id_,
       render_frame_id_,
       listener.get())) {
-    screen_availability_listeners_[url] = std::move(listener);
+    screen_availability_listeners_[availability_url] = std::move(listener);
   } else {
     DVLOG(1) << "AddScreenAvailabilityListener failed. Ignoring request.";
   }
 }
 
 void PresentationServiceImpl::StopListeningForScreenAvailability(
-    const std::string& url) {
+    const mojo::String& url) {
   DVLOG(2) << "StopListeningForScreenAvailability " << url;
   if (!delegate_)
     return;
 
-  auto listener_it = screen_availability_listeners_.find(url);
+  const std::string& availability_url = url.get();
+  auto listener_it = screen_availability_listeners_.find(availability_url);
   if (listener_it == screen_availability_listeners_.end())
     return;
 
@@ -220,7 +218,7 @@ void PresentationServiceImpl::StopListeningForScreenAvailability(
   screen_availability_listeners_.erase(listener_it);
 }
 
-void PresentationServiceImpl::StartSession(const std::string& presentation_url,
+void PresentationServiceImpl::StartSession(const mojo::String& presentation_url,
                                            const NewSessionCallback& callback) {
   DVLOG(2) << "StartSession";
   if (!delegate_) {
@@ -249,8 +247,8 @@ void PresentationServiceImpl::StartSession(const std::string& presentation_url,
 }
 
 void PresentationServiceImpl::JoinSession(
-    const std::string& presentation_url,
-    const base::Optional<std::string>& presentation_id,
+    const mojo::String& presentation_url,
+    const mojo::String& presentation_id,
     const NewSessionCallback& callback) {
   DVLOG(2) << "JoinSession";
   if (!delegate_) {
@@ -267,8 +265,10 @@ void PresentationServiceImpl::JoinSession(
     return;
   }
   delegate_->JoinSession(
-      render_process_id_, render_frame_id_, presentation_url,
-      presentation_id.value_or(std::string()),
+      render_process_id_,
+      render_frame_id_,
+      presentation_url,
+      presentation_id,
       base::Bind(&PresentationServiceImpl::OnJoinSessionSucceeded,
                  weak_factory_.GetWeakPtr(), request_session_id),
       base::Bind(&PresentationServiceImpl::OnJoinSessionError,
@@ -358,17 +358,18 @@ bool PresentationServiceImpl::RunAndEraseJoinSessionMojoCallback(
 }
 
 void PresentationServiceImpl::SetDefaultPresentationURL(
-    const std::string& url) {
+    const mojo::String& url) {
   DVLOG(2) << "SetDefaultPresentationURL";
   if (!delegate_)
     return;
 
-  if (default_presentation_url_ == url)
+  const std::string& new_default_url = url.get();
+  if (default_presentation_url_ == new_default_url)
     return;
 
-  default_presentation_url_ = url;
+  default_presentation_url_ = new_default_url;
   delegate_->SetDefaultPresentationUrl(
-      render_process_id_, render_frame_id_, url,
+      render_process_id_, render_frame_id_, new_default_url,
       base::Bind(&PresentationServiceImpl::OnDefaultPresentationStarted,
                  weak_factory_.GetWeakPtr()));
 }
@@ -405,16 +406,16 @@ void PresentationServiceImpl::OnSendMessageCallback(bool sent) {
 }
 
 void PresentationServiceImpl::CloseConnection(
-    const std::string& presentation_url,
-    const std::string& presentation_id) {
+    const mojo::String& presentation_url,
+    const mojo::String& presentation_id) {
   DVLOG(2) << "CloseConnection " << presentation_id;
   if (delegate_)
     delegate_->CloseConnection(render_process_id_, render_frame_id_,
                                presentation_id);
 }
 
-void PresentationServiceImpl::Terminate(const std::string& presentation_url,
-                                        const std::string& presentation_id) {
+void PresentationServiceImpl::Terminate(const mojo::String& presentation_url,
+                                        const mojo::String& presentation_id) {
   DVLOG(2) << "Terminate " << presentation_id;
   if (delegate_)
     delegate_->Terminate(render_process_id_, render_frame_id_, presentation_id);
@@ -465,15 +466,13 @@ void PresentationServiceImpl::OnSessionMessages(
   DCHECK(client_);
 
   DVLOG(2) << "OnSessionMessages";
-  std::vector<blink::mojom::SessionMessagePtr> mojo_messages(messages.size());
-  std::transform(messages.begin(), messages.end(), mojo_messages.begin(),
-                 [pass_ownership](PresentationSessionMessage* message) {
-                   return ToMojoSessionMessage(message, pass_ownership);
-                 });
+  mojo::Array<blink::mojom::SessionMessagePtr> mojoMessages(messages.size());
+  for (size_t i = 0; i < messages.size(); ++i)
+    mojoMessages[i] = ToMojoSessionMessage(messages[i], pass_ownership);
 
   client_->OnSessionMessagesReceived(
       blink::mojom::PresentationSessionInfo::From(session),
-      std::move(mojo_messages));
+      std::move(mojoMessages));
 }
 
 void PresentationServiceImpl::DidNavigateAnyFrame(

content/browser/presentation/presentation_service_impl.h

@@ -18,7 +18,6 @@
 #include "base/memory/linked_ptr.h"
 #include "base/memory/scoped_vector.h"
 #include "base/memory/weak_ptr.h"
-#include "base/optional.h"
 #include "content/common/content_export.h"
 #include "content/public/browser/navigation_details.h"
 #include "content/public/browser/presentation_screen_availability_listener.h"
@@ -150,22 +149,24 @@ class CONTENT_EXPORT PresentationServiceImpl
       PresentationServiceDelegate* delegate);
 
   // PresentationService implementation.
-  void SetDefaultPresentationURL(const std::string& url) override;
+  void SetDefaultPresentationURL(const mojo::String& url) override;
   void SetClient(blink::mojom::PresentationServiceClientPtr client) override;
-  void ListenForScreenAvailability(const std::string& url) override;
-  void StopListeningForScreenAvailability(const std::string& url) override;
-  void StartSession(const std::string& presentation_url,
-                    const NewSessionCallback& callback) override;
-  void JoinSession(const std::string& presentation_url,
-                   const base::Optional<std::string>& presentation_id,
-                   const NewSessionCallback& callback) override;
+  void ListenForScreenAvailability(const mojo::String& url) override;
+  void StopListeningForScreenAvailability(const mojo::String& url) override;
+  void StartSession(
+      const mojo::String& presentation_url,
+      const NewSessionCallback& callback) override;
+  void JoinSession(
+      const mojo::String& presentation_url,
+      const mojo::String& presentation_id,
+      const NewSessionCallback& callback) override;
   void SendSessionMessage(blink::mojom::PresentationSessionInfoPtr session_info,
                           blink::mojom::SessionMessagePtr session_message,
                           const SendSessionMessageCallback& callback) override;
-  void CloseConnection(const std::string& presentation_url,
-                       const std::string& presentation_id) override;
-  void Terminate(const std::string& presentation_url,
-                 const std::string& presentation_id) override;
+  void CloseConnection(const mojo::String& presentation_url,
+                       const mojo::String& presentation_id) override;
+  void Terminate(const mojo::String& presentation_url,
+                 const mojo::String& presentation_id) override;
   void ListenForSessionMessages(
       blink::mojom::PresentationSessionInfoPtr session) override;
 

content/browser/presentation/presentation_service_impl_unittest.cc

@@ -46,6 +46,14 @@ MATCHER_P(Equals, expected, "") {
 const char *const kPresentationId = "presentationId";
 const char *const kPresentationUrl = "http://foo.com/index.html";
 
+bool ArePresentationSessionMessagesEqual(
+    const blink::mojom::SessionMessage* expected,
+    const blink::mojom::SessionMessage* actual) {
+  return expected->type == actual->type &&
+         expected->message == actual->message &&
+         expected->data.Equals(actual->data);
+}
+
 void DoNothing(blink::mojom::PresentationSessionInfoPtr info,
                blink::mojom::PresentationErrorPtr error) {}
 
@@ -144,7 +152,7 @@ class MockPresentationServiceClient
     : public blink::mojom::PresentationServiceClient {
  public:
   MOCK_METHOD2(OnScreenAvailabilityUpdated,
-               void(const std::string& url, bool available));
+      void(const mojo::String& url, bool available));
   void OnConnectionStateChanged(
       blink::mojom::PresentationSessionInfoPtr connection,
       blink::mojom::PresentationConnectionState new_state) override {
@@ -157,19 +165,19 @@ class MockPresentationServiceClient
   void OnConnectionClosed(
       blink::mojom::PresentationSessionInfoPtr connection,
       blink::mojom::PresentationConnectionCloseReason reason,
-      const std::string& message) override {
+      const mojo::String& message) override {
     OnConnectionClosed(*connection, reason, message);
   }
   MOCK_METHOD3(OnConnectionClosed,
                void(const blink::mojom::PresentationSessionInfo& connection,
                     blink::mojom::PresentationConnectionCloseReason reason,
-                    const std::string& message));
+                    const mojo::String& message));
 
-  MOCK_METHOD1(OnScreenAvailabilityNotSupported, void(const std::string& url));
+  MOCK_METHOD1(OnScreenAvailabilityNotSupported, void(const mojo::String& url));
 
   void OnSessionMessagesReceived(
       blink::mojom::PresentationSessionInfoPtr session_info,
-      std::vector<blink::mojom::SessionMessagePtr> messages) override {
+      mojo::Array<blink::mojom::SessionMessagePtr> messages) override {
     messages_received_ = std::move(messages);
     MessagesReceived();
   }
@@ -182,7 +190,7 @@ class MockPresentationServiceClient
   MOCK_METHOD1(OnDefaultSessionStarted,
                void(const blink::mojom::PresentationSessionInfo& session_info));
 
-  std::vector<blink::mojom::SessionMessagePtr> messages_received_;
+  mojo::Array<blink::mojom::SessionMessagePtr> messages_received_;
 };
 
 class PresentationServiceImplTest : public RenderViewHostImplTestHarness {
@@ -216,8 +224,8 @@ class PresentationServiceImplTest : public RenderViewHostImplTestHarness {
     RenderViewHostImplTestHarness::TearDown();
   }
 
-  void ListenForScreenAvailabilityAndWait(const std::string& url,
-                                          bool delegate_success) {
+  void ListenForScreenAvailabilityAndWait(
+      const mojo::String& url, bool delegate_success) {
     base::RunLoop run_loop;
     // This will call to |service_impl_| via mojo. Process the message
     // using RunLoop.
@@ -253,8 +261,9 @@ class PresentationServiceImplTest : public RenderViewHostImplTestHarness {
     ASSERT_TRUE(listener_it->second);
 
     base::RunLoop run_loop;
-    EXPECT_CALL(mock_client_, OnScreenAvailabilityUpdated(url, available))
-        .WillOnce(InvokeWithoutArgs(&run_loop, &base::RunLoop::Quit));
+    EXPECT_CALL(mock_client_,
+                OnScreenAvailabilityUpdated(mojo::String(url), available))
+      .WillOnce(InvokeWithoutArgs(&run_loop, &base::RunLoop::Quit));
     listener_it->second->OnScreenAvailabilityChanged(available);
     run_loop.Run();
   }
@@ -290,11 +299,13 @@ class PresentationServiceImplTest : public RenderViewHostImplTestHarness {
   }
 
   void ExpectSessionMessages(
-      const std::vector<blink::mojom::SessionMessagePtr>& expected_msgs,
-      const std::vector<blink::mojom::SessionMessagePtr>& actual_msgs) {
+      const mojo::Array<blink::mojom::SessionMessagePtr>& expected_msgs,
+      const mojo::Array<blink::mojom::SessionMessagePtr>& actual_msgs) {
     EXPECT_EQ(expected_msgs.size(), actual_msgs.size());
-    for (size_t i = 0; i < actual_msgs.size(); ++i)
-      EXPECT_TRUE(expected_msgs[i].Equals(actual_msgs[i]));
+    for (size_t i = 0; i < actual_msgs.size(); ++i) {
+      EXPECT_TRUE(ArePresentationSessionMessagesEqual(expected_msgs[i].get(),
+                                                      actual_msgs[i].get()));
+    }
   }
 
   void ExpectSendSessionMessageCallback(bool success) {
@@ -307,14 +318,14 @@ class PresentationServiceImplTest : public RenderViewHostImplTestHarness {
   void RunListenForSessionMessages(const std::string& text_msg,
                                    const std::vector<uint8_t>& binary_data,
                                    bool pass_ownership) {
-    std::vector<blink::mojom::SessionMessagePtr> expected_msgs(2);
+    mojo::Array<blink::mojom::SessionMessagePtr> expected_msgs(2);
     expected_msgs[0] = blink::mojom::SessionMessage::New();
     expected_msgs[0]->type = blink::mojom::PresentationMessageType::TEXT;
     expected_msgs[0]->message = text_msg;
     expected_msgs[1] = blink::mojom::SessionMessage::New();
     expected_msgs[1]->type =
         blink::mojom::PresentationMessageType::ARRAY_BUFFER;
-    expected_msgs[1]->data = binary_data;
+    expected_msgs[1]->data = mojo::Array<uint8_t>::From(binary_data);
 
     blink::mojom::PresentationSessionInfoPtr session(
         blink::mojom::PresentationSessionInfo::New());
@@ -505,11 +516,11 @@ TEST_F(PresentationServiceImplTest, ListenForConnectionClose) {
     closed_info.close_reason = PRESENTATION_CONNECTION_CLOSE_REASON_WENT_AWAY;
     closed_info.message = "Foo";
 
-    EXPECT_CALL(
-        mock_client_,
-        OnConnectionClosed(
-            Equals(presentation_connection),
-            blink::mojom::PresentationConnectionCloseReason::WENT_AWAY, "Foo"))
+    EXPECT_CALL(mock_client_,
+                OnConnectionClosed(
+                    Equals(presentation_connection),
+                    blink::mojom::PresentationConnectionCloseReason::WENT_AWAY,
+                    mojo::String("Foo")))
         .WillOnce(InvokeWithoutArgs(&run_loop, &base::RunLoop::Quit));
     state_changed_cb.Run(closed_info);
     run_loop.Run();
@@ -569,9 +580,11 @@ TEST_F(PresentationServiceImplTest, StartSessionError) {
 
 TEST_F(PresentationServiceImplTest, JoinSessionSuccess) {
   service_ptr_->JoinSession(
-      kPresentationUrl, base::Optional<std::string>(kPresentationId),
-      base::Bind(&PresentationServiceImplTest::ExpectNewSessionCallbackSuccess,
-                 base::Unretained(this)));
+      kPresentationUrl,
+      kPresentationId,
+      base::Bind(
+          &PresentationServiceImplTest::ExpectNewSessionCallbackSuccess,
+          base::Unretained(this)));
   base::RunLoop run_loop;
   base::Callback<void(const PresentationSessionInfo&)> success_cb;
   EXPECT_CALL(mock_delegate_, JoinSession(
@@ -589,9 +602,11 @@ TEST_F(PresentationServiceImplTest, JoinSessionSuccess) {
 
 TEST_F(PresentationServiceImplTest, JoinSessionError) {
   service_ptr_->JoinSession(
-      kPresentationUrl, base::Optional<std::string>(kPresentationId),
-      base::Bind(&PresentationServiceImplTest::ExpectNewSessionCallbackError,
-                 base::Unretained(this)));
+      kPresentationUrl,
+      kPresentationId,
+      base::Bind(
+          &PresentationServiceImplTest::ExpectNewSessionCallbackError,
+          base::Unretained(this)));
   base::RunLoop run_loop;
   base::Callback<void(const PresentationError&)> error_cb;
   EXPECT_CALL(mock_delegate_, JoinSession(
@@ -704,7 +719,7 @@ TEST_F(PresentationServiceImplTest, SendArrayBuffer) {
   blink::mojom::SessionMessagePtr message_request(
       blink::mojom::SessionMessage::New());
   message_request->type = blink::mojom::PresentationMessageType::ARRAY_BUFFER;
-  message_request->data = data;
+  message_request->data = mojo::Array<uint8_t>::From(data);
   service_ptr_->SendSessionMessage(
       std::move(session), std::move(message_request),
       base::Bind(&PresentationServiceImplTest::ExpectSendSessionMessageCallback,
@@ -748,7 +763,7 @@ TEST_F(PresentationServiceImplTest, SendArrayBufferWithExceedingLimit) {
   blink::mojom::SessionMessagePtr message_request(
       blink::mojom::SessionMessage::New());
   message_request->type = blink::mojom::PresentationMessageType::ARRAY_BUFFER;
-  message_request->data = data;
+  message_request->data = mojo::Array<uint8_t>::From(data);
   service_ptr_->SendSessionMessage(
       std::move(session), std::move(message_request),
       base::Bind(&PresentationServiceImplTest::ExpectSendSessionMessageCallback,
@@ -779,7 +794,7 @@ TEST_F(PresentationServiceImplTest, SendBlobData) {
   blink::mojom::SessionMessagePtr message_request(
       blink::mojom::SessionMessage::New());
   message_request->type = blink::mojom::PresentationMessageType::BLOB;
-  message_request->data = data;
+  message_request->data = mojo::Array<uint8_t>::From(data);
   service_ptr_->SendSessionMessage(
       std::move(session), std::move(message_request),
       base::Bind(&PresentationServiceImplTest::ExpectSendSessionMessageCallback,

content/renderer/presentation/presentation_dispatcher.cc

@@ -313,9 +313,10 @@ 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();
@@ -337,8 +338,9 @@ void PresentationDispatcher::OnScreenAvailabilityUpdated(const std::string& url,
 }
 
 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();
@@ -405,7 +407,7 @@ void PresentationDispatcher::OnConnectionStateChanged(
 void PresentationDispatcher::OnConnectionClosed(
     blink::mojom::PresentationSessionInfoPtr connection,
     blink::mojom::PresentationConnectionCloseReason reason,
-    const std::string& message) {
+    const mojo::String& message) {
   if (!controller_)
     return;
 
@@ -418,7 +420,7 @@ void PresentationDispatcher::OnConnectionClosed(
 
 void PresentationDispatcher::OnSessionMessagesReceived(
     blink::mojom::PresentationSessionInfoPtr session_info,
-    std::vector<blink::mojom::SessionMessagePtr> messages) {
+    mojo::Array<blink::mojom::SessionMessagePtr> messages) {
   if (!controller_)
     return;
 
@@ -429,18 +431,16 @@ void PresentationDispatcher::OnSessionMessagesReceived(
         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: {
@@ -519,7 +519,8 @@ PresentationDispatcher::CreateSendBinaryMessageRequest(
   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));
 }

content/renderer/presentation/presentation_dispatcher.h

@@ -97,8 +97,8 @@ class CONTENT_EXPORT PresentationDispatcher
   void OnDestruct() override;
 
   // blink::mojom::PresentationServiceClient
-  void OnScreenAvailabilityNotSupported(const std::string& url) override;
-  void OnScreenAvailabilityUpdated(const std::string& url,
+  void OnScreenAvailabilityNotSupported(const mojo::String& url) override;
+  void OnScreenAvailabilityUpdated(const mojo::String& url,
                                    bool available) override;
   void OnConnectionStateChanged(
       blink::mojom::PresentationSessionInfoPtr connection,
@@ -106,10 +106,10 @@ class CONTENT_EXPORT PresentationDispatcher
   void OnConnectionClosed(
       blink::mojom::PresentationSessionInfoPtr connection,
       blink::mojom::PresentationConnectionCloseReason reason,
-      const std::string& message) override;
+      const mojo::String& message) override;
   void OnSessionMessagesReceived(
       blink::mojom::PresentationSessionInfoPtr session_info,
-      std::vector<blink::mojom::SessionMessagePtr> messages) override;
+      mojo::Array<blink::mojom::SessionMessagePtr> messages) override;
   void OnDefaultSessionStarted(
       blink::mojom::PresentationSessionInfoPtr session_info) override;
 

third_party/WebKit/public/BUILD.gn

@@ -171,13 +171,13 @@ mojom("mojo_bindings") {
     "platform/modules/offscreencanvas/offscreen_canvas_surface.mojom",
     "platform/modules/permissions/permission.mojom",
     "platform/modules/permissions/permission_status.mojom",
+    "platform/modules/presentation/presentation.mojom",
     "platform/modules/serviceworker/service_worker_event_status.mojom",
     "platform/modules/wake_lock/wake_lock_service.mojom",
     "platform/modules/webshare/webshare.mojom",
   ]
   public_deps = [
     ":android_mojo_bindings",
-    ":new_wrapper_types_mojo_bindings",
     "//cc/ipc:interfaces_surfaceid_only",
     "//device/bluetooth/public/interfaces:bluetooth_mojom_bluetooth_uuid",
     "//url/mojo:url_mojom_origin",
@@ -186,13 +186,6 @@ mojom("mojo_bindings") {
   use_new_wrapper_types = false
 }
 
-# GYP version: WebKit/public/blink.gyp:new_wrapper_types_mojo_bindings
-mojom("new_wrapper_types_mojo_bindings") {
-  sources = [
-    "platform/modules/presentation/presentation.mojom",
-  ]
-}
-
 # GYP version: WebKit/public/blink.gyp:android_mojo_bindings_java
 mojom("android_mojo_bindings") {
   sources = [

third_party/WebKit/public/blink.gyp

@@ -45,6 +45,7 @@
             'platform/modules/offscreencanvas/offscreen_canvas_surface.mojom',
             'platform/modules/permissions/permission.mojom',
             'platform/modules/permissions/permission_status.mojom',
+            'platform/modules/presentation/presentation.mojom',
             'platform/modules/serviceworker/service_worker_event_status.mojom',
             'platform/modules/wake_lock/wake_lock_service.mojom',
             'platform/modules/webshare/webshare.mojom',
@@ -53,10 +54,6 @@
         'blink_android_mojo_sources': [
             'platform/modules/payments/payment_request.mojom',
         ],
-        # Duplicated in GN: //third_party/WebKit/public:new_wrapper_types_mojo_bindings
-        'blink_new_wrapper_types_mojo_sources': [
-            'platform/modules/presentation/presentation.mojom',
-        ],
         'blink_typemap_sources': [
             '<(DEPTH)/cc/ipc/surface_id.typemap',
             '<(DEPTH)/cc/ipc/surface_sequence.typemap',
@@ -139,29 +136,6 @@
                 '../../../mojo/mojom_bindings_generator_explicit.gypi',
             ],
         },
-        {
-            # GN version: //third_party/WebKit/public:new_wrapper_types_mojo_bindings_blink
-            # (generated by //third_party/WebKit/public:new_wrapper_types_mojo_bindings)
-            'target_name': 'new_wrapper_types_mojo_bindings_blink_mojom',
-            'type': 'none',
-            'variables': {
-                'mojom_files': [
-                    '<@(blink_new_wrapper_types_mojo_sources)',
-                ],
-                'mojom_typemaps': [
-                    '../Source/platform/mojo/SecurityOrigin.typemap',
-                    '<@(blink_typemap_sources)',
-                ],
-                'for_blink': 'true',
-            },
-            'dependencies' : [
-                '<(DEPTH)/cc/ipc/cc_ipc.gyp:interfaces_blink',
-                '<(DEPTH)/url/url.gyp:url_mojom_for_blink',
-            ],
-            'includes': [
-                '../../../mojo/mojom_bindings_generator_explicit.gypi',
-            ],
-        },
         {
             # GN version: //third_party/WebKit/public:mojo_bindings
             'target_name': 'mojo_bindings_mojom',
@@ -186,27 +160,6 @@
                 '../../../mojo/mojom_bindings_generator_explicit.gypi',
             ],
         },
-        {
-            # GN version: //third_party/WebKit/public:new_wrapper_types_mojo_bindings
-            'target_name': 'new_wrapper_types_mojo_bindings_mojom',
-            'type': 'none',
-            'variables': {
-                'mojom_files': [
-                    '<@(blink_new_wrapper_types_mojo_sources)',
-                ],
-                'mojom_typemaps': [
-                    '<(DEPTH)/url/mojo/origin.typemap',
-                    '<@(blink_typemap_sources)',
-                ],
-            },
-            'dependencies' : [
-                '<(DEPTH)/cc/ipc/cc_ipc.gyp:interfaces',
-                '<(DEPTH)/url/url.gyp:url_mojom',
-            ],
-            'includes': [
-                '../../../mojo/mojom_bindings_generator_explicit.gypi',
-            ],
-        },
         {
             # GN version: //third_party/WebKit/public:mojo_bindings
             'target_name': 'mojo_bindings',
@@ -216,8 +169,6 @@
             'dependencies': [
                 'mojo_bindings_blink_mojom',
                 'mojo_bindings_mojom',
-                'new_wrapper_types_mojo_bindings_blink_mojom',
-                'new_wrapper_types_mojo_bindings_mojom',
                 '../../../mojo/mojo_public.gyp:mojo_cpp_bindings',
                 '../../../device/bluetooth/bluetooth.gyp:bluetooth_mojom',
                 '<(DEPTH)/cc/ipc/cc_ipc.gyp:interfaces',