Ignore certain messages in plugin broker process if they are not sent by the

content/ppapi_plugin/ppapi_thread.cc

 // Copyright (c) 2012 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/ppapi_plugin/ppapi_thread.h"
 
 #include <stddef.h>
 
 #include <limits>
 
@@ skipping 426 matching lines @@
 
   ReportLoadResult(path, LOAD_SUCCESS);
 }
 
 void PpapiThread::OnCreateChannel(base::ProcessId renderer_pid,
                                   int renderer_child_id,
                                   bool incognito) {
   IPC::ChannelHandle channel_handle;
 
   if (!plugin_entry_points_.get_interface ||  // Plugin couldn't be loaded.
-      !SetupRendererChannel(renderer_pid, renderer_child_id, incognito,
-                            &channel_handle)) {
+      !SetupChannel(renderer_pid, renderer_child_id, incognito,
+                    &channel_handle)) {
     Send(new PpapiHostMsg_ChannelCreated(IPC::ChannelHandle()));
     return;
   }
 
   Send(new PpapiHostMsg_ChannelCreated(channel_handle));
 }
 
 void PpapiThread::OnSetNetworkState(bool online) {
   // Note the browser-process side shouldn't send us these messages in the
   // first unless the plugin has dev permissions, so we don't need to check
@@ skipping 17 matching lines @@
   volatile int* null_pointer = nullptr;
   *null_pointer = 0;
 }
 
 void PpapiThread::OnHang() {
   // Intentionally hang upon the request of the browser.
   for (;;)
     base::PlatformThread::Sleep(base::TimeDelta::FromSeconds(1));
 }
 
-bool PpapiThread::SetupRendererChannel(base::ProcessId renderer_pid,
-                                       int renderer_child_id,
-                                       bool incognito,
-                                       IPC::ChannelHandle* handle) {
+bool PpapiThread::SetupChannel(base::ProcessId renderer_pid,
+                               int renderer_child_id,
+                               bool incognito,
+                               IPC::ChannelHandle* handle) {
   DCHECK(is_broker_ == (connect_instance_func_ != NULL));
   IPC::ChannelHandle plugin_handle;
   plugin_handle.name = IPC::Channel::GenerateVerifiedChannelID(
       base::StringPrintf(
           "%d.r%d", base::GetCurrentProcId(), renderer_child_id));
 
   ppapi::proxy::ProxyChannel* dispatcher = NULL;
   bool init_result = false;
   if (is_broker_) {
+    bool peer_is_browser = renderer_pid == base::kNullProcessId;
     BrokerProcessDispatcher* broker_dispatcher =
         new BrokerProcessDispatcher(plugin_entry_points_.get_interface,
-                                    connect_instance_func_);
+                                    connect_instance_func_, peer_is_browser);
     init_result = broker_dispatcher->InitBrokerWithChannel(this,
                                                            renderer_pid,
                                                            plugin_handle,
                                                            false);
     dispatcher = broker_dispatcher;
   } else {
+    DCHECK_NE(base::kNullProcessId, renderer_pid);

[bbudge, 2016/06/14 23:16:53]

I'm not very familiar with this part of Pepper, but would a CHECK_NE here
prevent the plugin from crashing the browser process (where you CHECK_NE?)

[yzshen1, 2016/06/14 23:24:47]

We get here because we get a create channel request from the browser, so we have
already passed the CHECK_NE in the browser process.

So I think it won't help to make this a CHECK_NE. WDYT? Thanks!

(I am not familiar with this part of code anymore, either.)

[bbudge, 2016/06/14 23:42:16]

Thanks for clarifying!

     PluginProcessDispatcher* plugin_dispatcher =
         new PluginProcessDispatcher(plugin_entry_points_.get_interface,
                                     permissions_,
                                     incognito);
     init_result = plugin_dispatcher->InitPluginWithChannel(this,
                                                            renderer_pid,
                                                            plugin_handle,
                                                            false);
     dispatcher = plugin_dispatcher;
   }
@@ skipping 67 matching lines @@
           GetHistogramName(is_broker_, "LoadTime", path),
           base::TimeDelta::FromMilliseconds(1),
           base::TimeDelta::FromSeconds(10),
           50,
           base::HistogramBase::kUmaTargetedHistogramFlag);
 
   histogram->AddTime(load_time);
 }
 
 }  // namespace content