Get all the resources relative to a single base. Currently the same base

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

 // 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.
 
 #ifndef NATIVE_CLIENT_SRC_TRUSTED_PLUGIN_PNACL_COORDINATOR_H_
 #define NATIVE_CLIENT_SRC_TRUSTED_PLUGIN_PNACL_COORDINATOR_H_
 
 #include <set>
 #include <map>
 #include <vector>
@@ skipping 72 matching lines @@
       subprocesses_should_die_(false) {
         NaClXMutexCtor(&subprocess_mu_);
   }
 
   virtual ~PnaclCoordinator();
 
   // Initialize() can only be called once during the lifetime of this instance.
   void Initialize(Plugin* instance);
 
   void BitcodeToNative(const nacl::string& pexe_url,
-                       const nacl::string& llc_url,
-                       const nacl::string& ld_url,
                        const pp::CompletionCallback& finish_callback);
 
   // Call this to take ownership of the FD of the translated nexe after
   // BitcodeToNative has completed (and the finish_callback called).
   nacl::DescWrapper* ReleaseTranslatedFD() {
     return translated_fd_.release();
   }
 
   int32_t GetLoadedFileDesc(int32_t pp_error,
                             const nacl::string& url,
                             const nacl::string& component);
 
   // Run when faced with a PPAPI error condition. It brings control back to the
   // plugin by invoking the |translate_notify_callback_|.
   void PnaclPpapiError(int32_t pp_error);
   // Run |translate_notify_callback_| with an error condition that is not
   // PPAPI specific.
   void PnaclNonPpapiError();
   // Wrapper for Plugin ReportLoadAbort.
   void ReportLoadAbort();
   // Wrapper for Plugin ReportLoadError.
   void ReportLoadError(const ErrorInfo& error);
 
-
-
   // Accessors for use by helper threads.
+  nacl::string resource_base_url() const { return resource_base_url_; }
   Plugin* plugin() const { return plugin_; }
   nacl::string llc_url() const { return llc_url_; }
   NaClSubprocess* llc_subprocess() const { return llc_subprocess_; }
   bool StartLlcSubProcess();
   nacl::string ld_url() const { return ld_url_; }
   NaClSubprocess* ld_subprocess() const { return ld_subprocess_; }
   bool StartLdSubProcess();
   bool SubprocessesShouldDie();
   void SetSubprocessesShouldDie(bool subprocesses_should_die);
   PnaclResources* resources() const { return resources_.get(); }
@@ skipping 15 matching lines @@
   void PnaclDidFinish(int32_t pp_error, PnaclTranslationUnit* translation_unit);
 
  private:
   NACL_DISALLOW_COPY_AND_ASSIGN(PnaclCoordinator);
 
   Plugin* plugin_;
   pp::CompletionCallback translate_notify_callback_;
   pp::CompletionCallbackFactory<PnaclCoordinator> callback_factory_;
 
   // URLs used to lookup downloaded resources.
+  nacl::string resource_base_url_;
   nacl::string llc_url_;
   nacl::string ld_url_;
 
   // Helper subprocesses loaded by the plugin (deleted by the plugin).
   // We may want to do cleanup ourselves when we are in the
   // business of compiling multiple bitcode objects / libraries, and
   // if we truly cannot reuse existing loaded subprocesses.
   NaClSubprocess* llc_subprocess_;
   NaClSubprocess* ld_subprocess_;
   bool subprocesses_should_die_;
@@ skipping 10 matching lines @@
   nacl::scoped_ptr<NaClThread> link_thread_;
 
   // An auxiliary class that manages downloaded resources.
   nacl::scoped_ptr<PnaclResources> resources_;
 };
 
 //----------------------------------------------------------------------
 
 }  // namespace plugin;
 #endif  // NATIVE_CLIENT_SRC_TRUSTED_PLUGIN_PNACL_COORDINATOR_H_