PPB_UDPSocket_Private is switched to the new Pepper proxy.

content/browser/renderer_host/pepper/browser_ppapi_host_impl.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/browser/renderer_host/pepper/browser_ppapi_host_impl.h"
 
 #include "content/browser/renderer_host/pepper/pepper_message_filter.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/render_view_host.h"
 #include "ipc/ipc_message_macros.h"
 
 namespace content {
 
 // static
 BrowserPpapiHost* BrowserPpapiHost::CreateExternalPluginProcess(
     IPC::Sender* sender,
     ppapi::PpapiPermissions permissions,
     base::ProcessHandle plugin_child_process,
     int plugin_child_process_id,
+    ProcessType plugin_child_process_type,
     IPC::ChannelProxy* channel,
     net::HostResolver* host_resolver,
     int render_process_id,
     int render_view_id) {
   // TODO(raymes): Figure out how to plumb plugin_name and
   // profile_data_directory through for NaCl. They are currently only needed for
   // PPB_Flash_File interfaces so it doesn't matter.
   std::string plugin_name;
   FilePath profile_data_directory;
   BrowserPpapiHostImpl* browser_ppapi_host =
       new BrowserPpapiHostImpl(sender, permissions, plugin_name,
-                               profile_data_directory, plugin_child_process_id);
+                               profile_data_directory,
+                               plugin_child_process_id,
+                               plugin_child_process_type);
   browser_ppapi_host->set_plugin_process_handle(plugin_child_process);
 
   channel->AddFilter(
-      new PepperMessageFilter(PepperMessageFilter::NACL,
+      new PepperMessageFilter(plugin_child_process_type,

[dmichael (off chromium), 2012/12/12 23:23:38]

I'm not sure I understand why you are changing the process type stuff. My
understanding was that it was just for "sanity checking", and part of the value
is that we can see locally what type it is. E.g., here, it's nice to know at a
glance that its type is "NACL".

[ygorshenin1, 2012/12/18 12:07:16]

Because there are different policies for nacl- and out-of-process- plugins.
Please, take a look at:
http://code.google.com/searchframe#OAMlx_jo-ck/src/content/browser/renderer_h....
The purpose of this CL is to switch UDP interface to the new proxy on the one
hand and to be as more close to the previous implementation as possible on
another.

On 2012/12/12 23:23:38, dmichael wrote:

[dmichael (off chromium), 2012/12/22 00:35:08]

But don't we only come in to this code path if the process type is NACL? I
understand why the process type code exists, but I'm not sure why you're
changing the type and removing the specific value from call-sites.
See:
http://code.google.com/searchframe#OAMlx_jo-ck/src/content/browser/renderer_h...
It looks like we only get here for NaCl, so it's not clear to me why you needed
to add a new parameter to CreateExternalPluginProcess. And that constructor
doesn't work if the value is not PROCESS_TYPE_NACL_LOADER. I'm fine with using
content::ProcessType, though.

[ygorshenin1, 2012/12/24 14:41:43]

Because I don't understand why do we need PepperMessageFilter::ProcessType while
there are already exists ProcessType enum. And why not to check
plugin_child_process_type for sanity one more time in the corresponding
PepperMessageFilter constructor?

On 2012/12/22 00:35:08, dmichael wrote:

[dmichael (off chromium), 2013/01/10 05:57:16]

I'm fine with using content::ProcessType. Makes sense.
We already do check it there, I think. What I don't understand is why you're
changing the signature of CreateExternalPluginProcess to add a ProcessType
parameter, when we always know that the type is PROCESS_TYPE_NACL_LOADER. It's a
minor point, but I think I like it a bit better without the parameter, and using
PROCESS_TYPE_NACL_LOADER explicitly.

[ygorshenin1, 2013/01/10 11:36:12]

OK, agree. Done.

On 2013/01/10 05:57:16, dmichael wrote:

                               permissions,
                               host_resolver,
                               render_process_id,
                               render_view_id));
   channel->AddFilter(browser_ppapi_host->message_filter());
 
   return browser_ppapi_host;
 }
 
 BrowserPpapiHostImpl::BrowserPpapiHostImpl(
     IPC::Sender* sender,
     const ppapi::PpapiPermissions& permissions,
     const std::string& plugin_name,
     const FilePath& profile_data_directory,
-    int plugin_process_id)
+    int plugin_process_id,
+    ProcessType plugin_process_type)
     : ppapi_host_(sender, permissions),
       plugin_process_handle_(base::kNullProcessHandle),
       plugin_name_(plugin_name),
       profile_data_directory_(profile_data_directory),
-      plugin_process_id_(plugin_process_id) {
+      plugin_process_id_(plugin_process_id),
+      plugin_process_type_(plugin_process_type) {
   message_filter_ = new HostMessageFilter(&ppapi_host_);
   ppapi_host_.AddHostFactoryFilter(scoped_ptr<ppapi::host::HostFactory>(
       new ContentBrowserPepperHostFactory(this)));
 }
 
 BrowserPpapiHostImpl::~BrowserPpapiHostImpl() {
   // Notify the filter so it won't foward messages to us.
   message_filter_->OnHostDestroyed();
 }
 
@@ skipping 75 matching lines @@
   */
   return ppapi_host_->OnMessageReceived(msg);
 }
 
 void BrowserPpapiHostImpl::HostMessageFilter::OnHostDestroyed() {
   DCHECK(ppapi_host_);
   ppapi_host_ = NULL;
 }
 
 }  // namespace content