Add ability to load pnacl resources from DIR_PNACL_COMPONENT.

ppapi/native_client/src/trusted/plugin/pnacl_coordinator.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 "native_client/src/trusted/plugin/pnacl_coordinator.h"
 
 #include <utility>
 #include <vector>
 
 #include "native_client/src/include/checked_cast.h"
@@ skipping 15 matching lines @@
 namespace {
 const char kPnaclTempDir[] = "/.pnacl";
 const uint32_t kCopyBufSize = 512 << 10;
 }
 
 namespace plugin {
 
 //////////////////////////////////////////////////////////////////////
 //  Pnacl-specific manifest support.
 //////////////////////////////////////////////////////////////////////
-class ExtensionManifest : public Manifest {
+
+class PnaclManifest : public Manifest {
  public:
-  explicit ExtensionManifest(const pp::URLUtil_Dev* url_util)
+  explicit PnaclManifest(const pp::URLUtil_Dev* url_util,

[robertm, 2012/08/08 21:51:11]

now that the constructor has a second arg the "explicit" is not really necessary
anymore. 

[jvoung - send to chromium..., 2012/08/08 22:47:04]

Done.

+                         bool use_extension)
       : url_util_(url_util),
-        manifest_base_url_(PnaclUrls::GetExtensionUrl()) { }
-  virtual ~ExtensionManifest() { }
+        manifest_base_url_(PnaclUrls::GetBaseUrl(use_extension)) {
+    // TODO(jvoung): get rid of use_extension when we no longer rely
+    // on the chrome webstore extension.  Most of this Manifest stuff
+    // can also be simplified then.
+  }
+  virtual ~PnaclManifest() { }
 
   virtual bool GetProgramURL(nacl::string* full_url,
                              nacl::string* cache_identity,
                              ErrorInfo* error_info,
                              bool* pnacl_translate) const {
     // Does not contain program urls.
     UNREFERENCED_PARAMETER(full_url);
     UNREFERENCED_PARAMETER(cache_identity);
     UNREFERENCED_PARAMETER(error_info);
     UNREFERENCED_PARAMETER(pnacl_translate);
-    PLUGIN_PRINTF(("ExtensionManifest does not contain a program\n"));
+    PLUGIN_PRINTF(("PnaclManifest does not contain a program\n"));
     error_info->SetReport(ERROR_MANIFEST_GET_NEXE_URL,
                           "pnacl manifest does not contain a program.");
     return false;
   }
 
   virtual bool ResolveURL(const nacl::string& relative_url,
                           nacl::string* full_url,
                           ErrorInfo* error_info) const {
     // Does not do general URL resolution, simply appends relative_url to
     // the end of manifest_base_url_.
     UNREFERENCED_PARAMETER(error_info);
     *full_url = manifest_base_url_ + relative_url;
     return true;
   }
 
   virtual bool GetFileKeys(std::set<nacl::string>* keys) const {
     // Does not support enumeration.
-    PLUGIN_PRINTF(("ExtensionManifest does not support key enumeration\n"));
+    PLUGIN_PRINTF(("PnaclManifest does not support key enumeration\n"));
     UNREFERENCED_PARAMETER(keys);
     return false;
   }
 
   virtual bool ResolveKey(const nacl::string& key,
                           nacl::string* full_url,
                           nacl::string* cache_identity,
                           ErrorInfo* error_info,
                           bool* pnacl_translate) const {
     // All of the extension files are native (do not require pnacl translate).
     *pnacl_translate = false;
     // Do not cache these entries.
     *cache_identity = "";
     // We can only resolve keys in the files/ namespace.
     const nacl::string kFilesPrefix = "files/";
     size_t files_prefix_pos = key.find(kFilesPrefix);
     if (files_prefix_pos == nacl::string::npos) {
       error_info->SetReport(ERROR_MANIFEST_RESOLVE_URL,
                             "key did not start with files/");
       return false;
     }
     // Append what follows files to the pnacl URL prefix.
     nacl::string key_basename = key.substr(kFilesPrefix.length());
     return ResolveURL(key_basename, full_url, error_info);
   }
 
  private:
-  NACL_DISALLOW_COPY_AND_ASSIGN(ExtensionManifest);
+  NACL_DISALLOW_COPY_AND_ASSIGN(PnaclManifest);
 
   const pp::URLUtil_Dev* url_util_;
   nacl::string manifest_base_url_;
 };
 
 // TEMPORARY: ld needs to look up dynamic libraries in the nexe's manifest
 // until metadata is complete in pexes.  This manifest lookup allows looking
 // for whether a resource requested by ld is in the nexe manifest first, and
 // if not, then consults the extension manifest.
 // TODO(sehr,jvoung,pdox): remove this when metadata is correct.
@@ skipping 89 matching lines @@
   pp::CompletionCallback resources_cb =
       coordinator->callback_factory_.NewCallback(
           &PnaclCoordinator::ResourcesDidLoad);
   coordinator->resources_.reset(
       new PnaclResources(plugin,
                          coordinator,
                          coordinator->manifest_.get(),
                          resource_urls,
                          resources_cb));
   CHECK(coordinator->resources_ != NULL);
-  coordinator->resources_->StartDownloads();
+  coordinator->resources_->StartLoad();
   // ResourcesDidLoad will be invoked when all resources have been received.
   return coordinator;
 }
 
 int32_t PnaclCoordinator::GetLoadedFileDesc(int32_t pp_error,
                                             const nacl::string& url,
                                             const nacl::string& component) {
   PLUGIN_PRINTF(("PnaclCoordinator::GetLoadedFileDesc (pp_error=%"
                  NACL_PRId32", url=%s, component=%s)\n", pp_error,
                  url.c_str(), component.c_str()));
@@ skipping 12 matching lines @@
 
 PnaclCoordinator::PnaclCoordinator(
     Plugin* plugin,
     const nacl::string& pexe_url,
     const nacl::string& cache_identity,
     const pp::CompletionCallback& translate_notify_callback)
   : translate_finish_error_(PP_OK),
     plugin_(plugin),
     translate_notify_callback_(translate_notify_callback),
     file_system_(new pp::FileSystem(plugin, PP_FILESYSTEMTYPE_LOCALTEMPORARY)),
-    manifest_(new ExtensionManifest(plugin->url_util())),
+    manifest_(new PnaclManifest(
+        plugin->url_util(),
+        plugin::PnaclUrls::UsePnaclExtension(plugin))),
     pexe_url_(pexe_url),
     cache_identity_(cache_identity),
     error_already_reported_(false),
     off_the_record_(false) {
   PLUGIN_PRINTF(("PnaclCoordinator::PnaclCoordinator (this=%p, plugin=%p)\n",
                  static_cast<void*>(this), static_cast<void*>(plugin)));
   callback_factory_.Initialize(this);
   ld_manifest_.reset(new PnaclLDManifest(plugin_->manifest(), manifest_.get()));
 }
 
@@ skipping 367 matching lines @@
                                   manifest_.get(),
                                   ld_manifest_.get(),
                                   obj_file_.get(),
                                   temp_nexe_file_.get(),
                                   &error_info_,
                                   resources_.get(),
                                   plugin_);
 }
 
 }  // namespace plugin