Pepper: Add VLOG support for NaCl plugins.

ppapi/proxy/plugin_main_nacl.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 <map>
 #include <set>
 
 #include "build/build_config.h"
 // Need to include this before most other files because it defines
 // IPC_MESSAGE_LOG_ENABLED. We need to use it to define
 // IPC_MESSAGE_MACROS_LOG_ENABLED so ppapi_messages.h will generate the
 // ViewMsgLog et al. functions.
 
+#include "base/command_line.h"
 #include "base/message_loop.h"
 #include "base/synchronization/waitable_event.h"
 #include "base/threading/thread.h"
 #include "components/tracing/child_trace_message_filter.h"
 #include "ipc/ipc_channel_handle.h"
 #include "ipc/ipc_logging.h"
 #include "ipc/ipc_message.h"
 #include "native_client/src/shared/ppapi_proxy/ppruntime.h"
 #include "native_client/src/shared/srpc/nacl_srpc.h"
 #include "native_client/src/untrusted/irt/irt_ppapi.h"
@@ skipping 52 matching lines @@
   virtual IPC::Sender* GetBrowserSender() OVERRIDE;
   virtual std::string GetUILanguage() OVERRIDE;
   virtual void PreCacheFont(const void* logfontw) OVERRIDE;
   virtual void SetActiveURL(const std::string& url) OVERRIDE;
 
   // IPC::Listener implementation.
   virtual bool OnMessageReceived(const IPC::Message& message) OVERRIDE;
 
  private:
   void OnMsgCreateNaClChannel(int renderer_id,
-                              const ppapi::PpapiPermissions& permissions,
-                              bool incognito,
+                              const ppapi::PpapiNaClChannelArgs& args,
                               SerializedHandle handle);
   void OnMsgResourceReply(
       const ppapi::proxy::ResourceMessageReplyParams& reply_params,
       const IPC::Message& nested_msg);
   void OnPluginDispatcherMessageReceived(const IPC::Message& msg);
 
   std::set<PP_Instance> instances_;
   std::map<uint32, PluginDispatcher*> plugin_dispatchers_;
   uint32 next_plugin_dispatcher_id_;
   scoped_refptr<base::MessageLoopProxy> message_loop_;
@@ skipping 74 matching lines @@
 bool PpapiDispatcher::OnMessageReceived(const IPC::Message& msg) {
   IPC_BEGIN_MESSAGE_MAP(PpapiDispatcher, msg)
     IPC_MESSAGE_HANDLER(PpapiMsg_CreateNaClChannel, OnMsgCreateNaClChannel)
     IPC_MESSAGE_HANDLER(PpapiPluginMsg_ResourceReply, OnMsgResourceReply)
     // All other messages are simply forwarded to a PluginDispatcher.
     IPC_MESSAGE_UNHANDLED(OnPluginDispatcherMessageReceived(msg))
   IPC_END_MESSAGE_MAP()
   return true;
 }
 
+static bool cmdline_and_logging_initialized = false;
+
 void PpapiDispatcher::OnMsgCreateNaClChannel(
     int renderer_id,
-    const ppapi::PpapiPermissions& permissions,
-    bool incognito,
+    const ppapi::PpapiNaClChannelArgs& args,
     SerializedHandle handle) {
+  if (!cmdline_and_logging_initialized) {

[dmichael (off chromium), 2013/04/10 23:10:22]

Does this ever happen more than once? If it really does, we should probably have
a separate message for the 1-time initialization stuff (which would the
permissions and incognito stuff)

+    CommandLine::Init(0, NULL);
+    for (size_t i = 0; i < args.switch_names.size(); ++i) {
+      DCHECK(i < args.switch_values.size());
+      CommandLine::ForCurrentProcess()->AppendSwitchASCII(
+          args.switch_names[i], args.switch_values[i]);
+    }
+    logging::InitLogging(
+        NULL,
+        logging::LOG_ONLY_TO_SYSTEM_DEBUG_LOG,
+        logging::DONT_LOCK_LOG_FILE,
+        logging::DELETE_OLD_LOG_FILE,
+        logging::DISABLE_DCHECK_FOR_NON_OFFICIAL_RELEASE_BUILDS);
+    cmdline_and_logging_initialized = true;
+  }
+
   // Tell the process-global GetInterface which interfaces it can return to the
   // plugin.
   ppapi::proxy::InterfaceList::SetProcessGlobalPermissions(
-      permissions);
+      args.permissions);
 
   PluginDispatcher* dispatcher =
-      new PluginDispatcher(::PPP_GetInterface, permissions, incognito);
+      new PluginDispatcher(::PPP_GetInterface, args.permissions,
+                           args.off_the_record);
   // The channel handle's true name is not revealed here.
   IPC::ChannelHandle channel_handle("nacl", handle.descriptor());
   if (!dispatcher->InitPluginWithChannel(this, base::kNullProcessId,
                                          channel_handle, false)) {
     delete dispatcher;
     return;
   }
   // From here, the dispatcher will manage its own lifetime according to the
   // lifetime of the attached channel.
 }
@@ skipping 72 matching lines @@
 
   PpapiDispatcher ppapi_dispatcher(io_thread.message_loop_proxy());
   plugin_globals.set_plugin_proxy_delegate(&ppapi_dispatcher);
 
   loop.Run();
 
   NaClSrpcModuleFini();
 
   return 0;
 }