Updates SessionMessage to ConnectionMessage.

content/browser/presentation/presentation_service_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 "content/browser/presentation/presentation_service_impl.h"
 
 #include <stddef.h>
 #include <stdint.h>
 #include <algorithm>
 #include <utility>
 
 #include "base/logging.h"
 #include "base/stl_util.h"
 #include "content/browser/presentation/presentation_type_converters.h"
 #include "content/public/browser/content_browser_client.h"
 #include "content/public/browser/navigation_details.h"
-#include "content/public/browser/presentation_session_message.h"
+#include "content/public/browser/presentation_connection_message.h"
 #include "content/public/browser/render_frame_host.h"
 #include "content/public/browser/render_process_host.h"
 #include "content/public/browser/web_contents.h"
 #include "content/public/common/content_client.h"
 #include "content/public/common/frame_navigate_params.h"
 #include "content/public/common/presentation_constants.h"
 
 namespace content {
 
 namespace {
 
 const int kInvalidRequestSessionId = -1;
 
 int GetNextRequestSessionId() {
   static int next_request_session_id = 0;
   return ++next_request_session_id;
 }
 
-// Converts a PresentationSessionMessage |input| to a SessionMessage.
+// Converts a PresentationConnectionMessage |input| to a ConnectionMessage.
 // |input|: The message to convert.
 // |pass_ownership|: If true, function may reuse strings or buffers from
 //     |input| without copying. |input| can be freely modified.
-blink::mojom::SessionMessagePtr ToMojoSessionMessage(
-    content::PresentationSessionMessage* input,
+blink::mojom::ConnectionMessagePtr ToMojoConnectionMessage(
+    content::PresentationConnectionMessage* input,
     bool pass_ownership) {
   DCHECK(input);
-  blink::mojom::SessionMessagePtr output(blink::mojom::SessionMessage::New());
+  blink::mojom::ConnectionMessagePtr output(
+      blink::mojom::ConnectionMessage::New());
   if (input->is_binary()) {
     // binary data
     DCHECK(input->data);

[dcheng, 2016/12/13 08:25:14]

I've mentioned this previously, but any chance this this will be typemapped
soon? It's been a few months, and it would be nice to clean this up to make
future security reviewers easier.

[CJ, 2016/12/13 22:05:35]

I'm new, so this is the first I've heard of this. Could you explain more? I
wouldn't mind doing it in the next CL if that's ok. 

[dcheng, 2016/12/13 22:39:12]

Yeah, a followup is fine, I just wanted to make sure this was on the radar: we
want to try to encourage idiomatic use of Mojo to make things easier for
security reviewers. One of the idioms is using something called StructTraits [1]
to have a consistent interface for validating Mojo IPC.

[1] https://www.chromium.org/developers/design-documents/mojo/type-mapping

-    output->type = blink::mojom::PresentationMessageType::ARRAY_BUFFER;
+    output->type = blink::mojom::PresentationMessageType::BINARY;
     if (pass_ownership) {
       output->data = std::move(*(input->data));
     } else {
       output->data = *(input->data);
     }
   } else {
     // string message
     output->type = blink::mojom::PresentationMessageType::TEXT;
     if (pass_ownership) {
       output->message = std::move(input->message);
     } else {
       output->message = input->message;
     }
   }
   return output;
 }
 
-std::unique_ptr<PresentationSessionMessage> GetPresentationSessionMessage(
-    blink::mojom::SessionMessagePtr input) {
-  std::unique_ptr<content::PresentationSessionMessage> output;
+std::unique_ptr<PresentationConnectionMessage> GetPresentationConnectionMessage(
+    blink::mojom::ConnectionMessagePtr input) {
+  std::unique_ptr<content::PresentationConnectionMessage> output;
   if (input.is_null())
     return output;
 
   switch (input->type) {
     case blink::mojom::PresentationMessageType::TEXT: {
-      // Return nullptr PresentationSessionMessage if invalid (unset |message|,
+      // Return nullptr PresentationConnectionMessage if invalid (unset
+      // |message|,
       // set |data|, or size too large).
       if (input->data || !input->message ||
-          input->message->size() > content::kMaxPresentationSessionMessageSize)
+          input->message->size() >
+              content::kMaxPresentationConnectionMessageSize)
         return output;
 
       output.reset(
-          new PresentationSessionMessage(PresentationMessageType::TEXT));
+          new PresentationConnectionMessage(PresentationMessageType::TEXT));
       output->message = std::move(input->message.value());
       return output;
     }
-    case blink::mojom::PresentationMessageType::ARRAY_BUFFER: {
-      // Return nullptr PresentationSessionMessage if invalid (unset |data|, set
+    case blink::mojom::PresentationMessageType::BINARY: {
+      // Return nullptr PresentationConnectionMessage if invalid (unset |data|,
+      // set
       // |message|, or size too large).
       if (!input->data || input->message ||
-          input->data->size() > content::kMaxPresentationSessionMessageSize)
+          input->data->size() > content::kMaxPresentationConnectionMessageSize)
         return output;
 
-      output.reset(new PresentationSessionMessage(
-          PresentationMessageType::ARRAY_BUFFER));
+      output.reset(
+          new PresentationConnectionMessage(PresentationMessageType::BINARY));
       output->data.reset(
           new std::vector<uint8_t>(std::move(input->data.value())));
       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)
-        return output;
-
-      output.reset(
-          new PresentationSessionMessage(PresentationMessageType::BLOB));
-      output->data.reset(
-          new std::vector<uint8_t>(std::move(input->data.value())));
-      return output;
     }
   }
 
   NOTREACHED() << "Invalid presentation message type " << input->type;
   return output;
 }
 
 void InvokeNewSessionCallbackWithError(
     const PresentationServiceImpl::NewSessionCallback& callback) {
   callback.Run(blink::mojom::PresentationSessionInfoPtr(),
@@ skipping 247 matching lines @@
   if (default_presentation_urls_ == presentation_urls)
     return;
 
   default_presentation_urls_ = presentation_urls;
   delegate_->SetDefaultPresentationUrls(
       render_process_id_, render_frame_id_, presentation_urls,
       base::Bind(&PresentationServiceImpl::OnDefaultPresentationStarted,
                  weak_factory_.GetWeakPtr()));
 }
 
-void PresentationServiceImpl::SendSessionMessage(
+void PresentationServiceImpl::SendConnectionMessage(
     blink::mojom::PresentationSessionInfoPtr session,
-    blink::mojom::SessionMessagePtr session_message,
-    const SendSessionMessageCallback& callback) {
-  DVLOG(2) << "SendSessionMessage";
-  DCHECK(!session_message.is_null());
+    blink::mojom::ConnectionMessagePtr connection_message,
+    const SendConnectionMessageCallback& callback) {
+  DVLOG(2) << "SendConnectionMessage";
+  DCHECK(!connection_message.is_null());
   // send_message_callback_ should be null by now, otherwise resetting of
   // send_message_callback_ with new callback will drop the old callback.
   if (!delegate_ || send_message_callback_) {
     callback.Run(false);
     return;
   }
 
-  send_message_callback_.reset(new SendSessionMessageCallback(callback));
+  send_message_callback_.reset(new SendConnectionMessageCallback(callback));
   delegate_->SendMessage(
       render_process_id_, render_frame_id_,
       session.To<PresentationSessionInfo>(),
-      GetPresentationSessionMessage(std::move(session_message)),
+      GetPresentationConnectionMessage(std::move(connection_message)),
       base::Bind(&PresentationServiceImpl::OnSendMessageCallback,
                  weak_factory_.GetWeakPtr()));
 }
 
 void PresentationServiceImpl::OnSendMessageCallback(bool sent) {
   // It is possible that Reset() is invoked before receiving this callback.
   // So, always check send_message_callback_ for non-null.
   if (send_message_callback_) {
     send_message_callback_->Run(sent);
     send_message_callback_.reset();
@@ skipping 37 matching lines @@
 
 bool PresentationServiceImpl::FrameMatches(
     content::RenderFrameHost* render_frame_host) const {
   if (!render_frame_host)
     return false;
 
   return render_frame_host->GetProcess()->GetID() == render_process_id_ &&
          render_frame_host->GetRoutingID() == render_frame_id_;
 }
 
-void PresentationServiceImpl::ListenForSessionMessages(
+void PresentationServiceImpl::ListenForConnectionMessages(
     blink::mojom::PresentationSessionInfoPtr session) {
-  DVLOG(2) << "ListenForSessionMessages";
+  DVLOG(2) << "ListenForConnectionMessages";
   if (!delegate_)
     return;
 
   PresentationSessionInfo session_info(session.To<PresentationSessionInfo>());
-  delegate_->ListenForSessionMessages(
+  delegate_->ListenForConnectionMessages(
       render_process_id_, render_frame_id_, session_info,
-      base::Bind(&PresentationServiceImpl::OnSessionMessages,
+      base::Bind(&PresentationServiceImpl::OnConnectionMessages,
                  weak_factory_.GetWeakPtr(), session_info));
 }
 
-void PresentationServiceImpl::OnSessionMessages(
+void PresentationServiceImpl::OnConnectionMessages(
     const PresentationSessionInfo& session,
-    const ScopedVector<PresentationSessionMessage>& messages,
+    const ScopedVector<PresentationConnectionMessage>& messages,
     bool pass_ownership) {
   DCHECK(client_);
 
-  DVLOG(2) << "OnSessionMessages";
-  std::vector<blink::mojom::SessionMessagePtr> mojo_messages(messages.size());
+  DVLOG(2) << "OnConnectionMessages";
+  std::vector<blink::mojom::ConnectionMessagePtr> mojo_messages(
+      messages.size());
   std::transform(messages.begin(), messages.end(), mojo_messages.begin(),
-                 [pass_ownership](PresentationSessionMessage* message) {
-                   return ToMojoSessionMessage(message, pass_ownership);
+                 [pass_ownership](PresentationConnectionMessage* message) {
+                   return ToMojoConnectionMessage(message, pass_ownership);
                  });
 
-  client_->OnSessionMessagesReceived(
+  client_->OnConnectionMessagesReceived(
       blink::mojom::PresentationSessionInfo::From(session),
       std::move(mojo_messages));
 }
 
 void PresentationServiceImpl::DidNavigateAnyFrame(
     content::RenderFrameHost* render_frame_host,
     const content::LoadCommittedDetails& details,
     const content::FrameNavigateParams& params) {
   DVLOG(2) << "PresentationServiceImpl::DidNavigateAnyFrame";
   if (!FrameMatches(render_frame_host))
@@ skipping 41 matching lines @@
 
   default_presentation_urls_.clear();
 
   screen_availability_listeners_.clear();
 
   start_session_request_id_ = kInvalidRequestSessionId;
   pending_start_session_cb_.reset();
 
   pending_join_session_cbs_.clear();
 
-  if (on_session_messages_callback_.get()) {
-    on_session_messages_callback_->Run(
-        mojo::Array<blink::mojom::SessionMessagePtr>());
-    on_session_messages_callback_.reset();
+  if (on_connection_messages_callback_.get()) {
+    on_connection_messages_callback_->Run(
+        mojo::Array<blink::mojom::ConnectionMessagePtr>());
+    on_connection_messages_callback_.reset();
   }
 
   if (send_message_callback_) {
     // Run the callback with false, indicating the renderer to stop sending
     // the requests and invalidate all pending requests.
     send_message_callback_->Run(false);
     send_message_callback_.reset();
   }
 }
 
@@ skipping 51 matching lines @@
 
 void PresentationServiceImpl::NewSessionCallbackWrapper::Run(
     blink::mojom::PresentationSessionInfoPtr session,
     blink::mojom::PresentationErrorPtr error) {
   DCHECK(!callback_.is_null());
   callback_.Run(std::move(session), std::move(error));
   callback_.Reset();
 }
 
 }  // namespace content