Move command line processing out of coordinator

ppapi/native_client/src/trusted/plugin/plugin.cc

 // Copyright (c) 2011 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.
 
 #ifdef _MSC_VER
 // Do not warn about use of std::copy with raw pointers.
 #pragma warning(disable : 4996)
 #endif
 
 #include "native_client/src/trusted/plugin/plugin.h"
@@ skipping 970 matching lines @@
     : pp::InstancePrivate(pp_instance),
       browser_interface_(NULL),
       scriptable_handle_(NULL),
       argc_(-1),
       argn_(NULL),
       argv_(NULL),
       main_subprocess_(kMainSubprocessId, NULL, NULL),
       nacl_ready_state_(UNSENT),
       nexe_error_reported_(false),
       wrapper_factory_(NULL),
+      pnacl_(NULL),
       last_error_string_(""),
       ppapi_proxy_(NULL),
       enable_dev_interfaces_(false),
       replayDidChangeView(false),
       replayHandleDocumentLoad(false),
       init_time_(0),
       ready_time_(0),
       nexe_size_(0),
       time_of_last_progress_event_(0) {
   PLUGIN_PRINTF(("Plugin::Plugin (this=%p, pp_instance=%"
                  NACL_PRId32")\n", static_cast<void*>(this), pp_instance));
   NaClSrpcModuleInit();
+  callback_factory_.Initialize(this);
   nexe_downloader_.Initialize(this);
-  pnacl_.Initialize(this);
-  callback_factory_.Initialize(this);
 }
 
 
 Plugin::~Plugin() {
   int64_t shutdown_start = NaClGetTimeOfDayMicroseconds();
 
   PLUGIN_PRINTF(("Plugin::~Plugin (this=%p, scriptable_handle=%p)\n",
                  static_cast<void*>(this),
                  static_cast<void*>(scriptable_handle())));
 
@@ skipping 282 matching lines @@
   PLUGIN_PRINTF(("Plugin::BitcodeDidTranslate (pp_error=%"NACL_PRId32")\n",
                  pp_error));
   if (pp_error != PP_OK) {
     // Error should have been reported by pnacl. Just return.
     PLUGIN_PRINTF(("Plugin::BitcodeDidTranslate error in Pnacl\n"));
     return;
   }
   // Inform JavaScript that we successfully translated the bitcode to a nexe.
   EnqueueProgressEvent(kProgressEventProgress);
   nacl::scoped_ptr<nacl::DescWrapper>
-      wrapper(pnacl_.ReleaseTranslatedFD());
+      wrapper(pnacl_->ReleaseTranslatedFD());
   ErrorInfo error_info;
   bool was_successful = LoadNaClModule(
       wrapper.get(), &error_info,
       callback_factory_.NewCallback(&Plugin::BitcodeDidTranslateContinuation),
       pp::BlockUntilComplete());
 
   if (!was_successful) {
     ReportLoadError(error_info);
   }
 }
@@ skipping 294 matching lines @@
     return;
   }
 
   if (SelectProgramURLFromManifest(&program_url, &error_info, &is_portable)) {
     set_nacl_ready_state(LOADING);
     // Inform JavaScript that we found a nexe URL to load.
     EnqueueProgressEvent(kProgressEventProgress);
     if (is_portable) {
       pp::CompletionCallback translate_callback =
           callback_factory_.NewCallback(&Plugin::BitcodeDidTranslate);
       // Will always call the callback on success or failure.

[robertm, 2011/12/13 17:06:39]

it might be useful for debugging to issue 
ProgressEventProgress events just before the return statements if this is not
already done inside the called functions

[sehr (please use chromium), 2011/12/13 20:05:04]

There are tests that rely on how many progress events are delivered, so this
would break them when we start running them on this path and today on the other
return path...

-      pnacl_.BitcodeToNative(program_url, translate_callback);
+      pnacl_ = PnaclCoordinator::BitcodeToNative(this,

[robertm, 2011/12/13 17:06:39]

is this overwritten every time?
maybe use a scoped ptr and reset.
Also, mention in a comment how it is used -- presumably it is needed for the
lifetime of the callback?
BTW: could it be passed into the callback and free there? 

[sehr (please use chromium), 2011/12/13 20:05:04]

Used a scoped_ptr.  The ugly thing is I think NaCl has been living with a
dangling file pointer for the nexe for a while.  I need to leave the temporary
file owner around until the sel_ldr is done, I think, so yes, this is a bit of 
unavoidable debt.

+                                                 program_url,
+                                                 translate_callback);
       return;
     } else {
       pp::CompletionCallback open_callback =
           callback_factory_.NewRequiredCallback(&Plugin::NexeFileDidOpen);
       // Will always call the callback on success or failure.
       CHECK(
           nexe_downloader_.Open(program_url,
                                 DOWNLOAD_TO_FILE,
                                 open_callback,
                                 &UpdateDownloadProgress));
@@ skipping 395 matching lines @@
   std::string scheme = canonicalized.AsString().substr(comps.scheme.begin,
                                                        comps.scheme.len);
   if (scheme == kChromeExtensionUriScheme)
     return SCHEME_CHROME_EXTENSION;
   if (scheme == kDataUriScheme)
     return SCHEME_DATA;
   return SCHEME_OTHER;
 }
 
 }  // namespace plugin