Refactor Pnacl coordinator

ppapi/native_client/src/trusted/plugin/pnacl_translate_thread.h

+// 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.
+
+#ifndef NATIVE_CLIENT_SRC_TRUSTED_PLUGIN_PNACL_TRANSLATE_THREAD_H_
+#define NATIVE_CLIENT_SRC_TRUSTED_PLUGIN_PNACL_TRANSLATE_THREAD_H_
+
+#include "native_client/src/include/nacl_scoped_ptr.h"
+#include "native_client/src/include/nacl_string.h"
+#include "native_client/src/shared/platform/nacl_threads.h"
+#include "native_client/src/shared/platform/nacl_sync_checked.h"
+
+#include "ppapi/cpp/completion_callback.h"
+
+namespace nacl {
+struct DescWrapper;
+}
+
+
+namespace plugin {
+
+class ErrorInfo;
+class LocalTempFile;
+class Manifest;
+class NaClSubprocess;
+class Plugin;
+class PnaclResources;
+
+class PnaclTranslateThread {
+ public:
+  PnaclTranslateThread();
+  virtual ~PnaclTranslateThread();
+  // Maybe better to encapsulate these into a class/struct?

[jvoung - send to chromium..., 2012/05/15 23:51:05]

Somewhat related to this -- these shared data-structures plus having the
coordinator own them, was why we were having surfaway (click back button and
crash) issues...  coordinator dtors all of them while they are still used by the
thread =(


One idea was to encapsulate these in an ref-counted struct or something (so that
might be a reason to have these in a struct).


However, there's also some shared state from starting the helper process from
this thread ("plugin_->LoadHelperNaClModule"), so that also has some shared
state that could be pulled out from under the thread (don't remember what,
though), and the plugin can start dtor'ing things before it gets to the
coordinator's dtor.

[Derek Schuff, 2012/05/16 16:47:46]

OK. so clearly we'll have to do something different here anyway in the future,
so for now i'll leave it as is and put a todo (obviously a fix for that belongs
in a different CL)
On 2012/05/15 23:51:05, jvoung wrote:

+  void RunTranslate(pp::CompletionCallback finish_callback,
+                    const Manifest* manifest,
+                    const Manifest* ld_manifest,
+                    LocalTempFile* obj_file,
+                    LocalTempFile* nexe_file,
+                    nacl::DescWrapper* pexe_wrapper,
+                    ErrorInfo* error_info,
+                    PnaclResources* resources,
+                    Plugin* plugin);
+  bool SubprocessesShouldDie();
+  // Signal the translate thread and subprocesses that they should stop.
+  void SetSubprocessesShouldDie(bool subprocesses_should_die);
+
+ private:
+  // Starts an individual llc or ld subprocess used for translation.
+  NaClSubprocess* StartSubprocess(const nacl::string& url,
+                                  const Manifest* manifest);
+  // Creates a helper thread to allow translations to be
+  // invoked via SRPC.  This is the helper thread function for translation.
+  static void WINAPI DoTranslateThread(void* arg);
+  // Signal that Pnacl translation failed, from the translation thread only.
+  void TranslateFailed(const nacl::string& error_string);
+  // Returns true if a the translate thread and subprocesses should stop.
+
+  // Callback to run when tasks are completed or an error has occurred.
+  pp::CompletionCallback report_translate_finished_;
+  // True if the translation thread and related subprocesses should exit.
+  bool subprocesses_should_die_;
+  // Used to guard and publish subprocesses_should_die_.
+  struct NaClMutex subprocess_mu_;
+
+  nacl::scoped_ptr<NaClThread> translate_thread_;
+
+  // Data about the translation files, owned by the coordinator
+  const Manifest* manifest_;
+  const Manifest* ld_manifest_;
+  LocalTempFile* obj_file_;
+  LocalTempFile* nexe_file_;
+  nacl::DescWrapper* pexe_wrapper_;
+  ErrorInfo *error_info_;
+  PnaclResources* resources_;
+  Plugin* plugin_;
+};
+
+}
+#endif // NATIVE_CLIENT_SRC_TRUSTED_PLUGIN_PNACL_TRANSLATE_THREAD_H_