Pepper: Move PnaclOptions outside trusted plugin.

ppapi/native_client/src/trusted/plugin/json_manifest.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 <algorithm>
 
 #include "ppapi/native_client/src/trusted/plugin/json_manifest.h"
 
 #include <stdlib.h>
 
 #include "native_client/src/include/nacl_base.h"
 #include "native_client/src/include/nacl_macros.h"
 #include "native_client/src/include/nacl_string.h"
 #include "native_client/src/include/portability.h"
 #include "native_client/src/shared/platform/nacl_check.h"
+#include "ppapi/c/private/ppb_nacl_private.h"
 #include "ppapi/cpp/dev/url_util_dev.h"
 #include "ppapi/cpp/var.h"
 #include "ppapi/native_client/src/trusted/plugin/plugin_error.h"
-#include "ppapi/native_client/src/trusted/plugin/pnacl_options.h"
 #include "ppapi/native_client/src/trusted/plugin/utility.h"
 #include "third_party/jsoncpp/source/include/json/reader.h"
 
 namespace plugin {
 
 namespace {
 // Top-level section name keys
 const char* const kProgramKey =     "program";
 const char* const kInterpreterKey = "interpreter";
 const char* const kFilesKey =       "files";
@@ skipping 342 matching lines @@
           PP_NACL_ERROR_MANIFEST_PROGRAM_MISSING_ARCH,
           nacl::string("manifest: no version of ") + parent_key +
           " given for current arch and no portable version found.");
       return false;
     }
   }
 
   return true;
 }
 
-void GrabUrlAndPnaclOptions(const Json::Value& url_spec,
+void GrabUrlAndPP_PNaClOptions(const Json::Value& url_spec,

[dmichael (off chromium), 2014/04/15 23:15:04]

I think you can keep the old name...  this looks awkward, and PP_ is kind of
like a namespace

                             nacl::string* url,
-                            PnaclOptions* pnacl_options) {
+                            PP_PNaClOptions* pnacl_options) {
   *url = url_spec[kUrlKey].asString();
-  pnacl_options->set_translate(true);
+  pnacl_options->translate = PP_TRUE;
   if (url_spec.isMember(kOptLevelKey)) {
     int32_t opt_raw = url_spec[kOptLevelKey].asInt();
-    // set_opt_level will normalize the values.
-    pnacl_options->set_opt_level(opt_raw);
+    int32_t opt_level;
+    if (opt_raw <= 0)
+      opt_level = 0;
+    else
+      opt_level = 2;

[dmichael (off chromium), 2014/04/15 23:15:04]

Maybe duplicate the comment from pnacl_options.cc, since this looks wrong
without that context?

+    pnacl_options->opt_level = opt_level;
   }
 }
 
 }  // namespace
 
 bool JsonManifest::Init(const nacl::string& manifest_json,
                         ErrorInfo* error_info) {
   if (error_info == NULL) {
     return false;
   }
@@ skipping 93 matching lines @@
       }
     }
   }
 
   return true;
 }
 
 bool JsonManifest::GetURLFromISADictionary(const Json::Value& dictionary,
                                            const nacl::string& parent_key,
                                            nacl::string* url,
-                                           PnaclOptions* pnacl_options,
+                                           PP_PNaClOptions* pnacl_options,
                                            bool* uses_nonsfi_mode,
                                            ErrorInfo* error_info) const {
   DCHECK(url != NULL && pnacl_options != NULL && error_info != NULL);
 
   // When the application actually requests a resolved URL, we must have
   // a matching entry (sandbox_isa_ or portable) for NaCl.
   if (!IsValidISADictionary(dictionary, parent_key, sandbox_isa_, true,
                             nonsfi_enabled_, error_info)) {
     error_info->SetReport(PP_NACL_ERROR_MANIFEST_RESOLVE_URL,
                           "architecture " + sandbox_isa_ +
@@ skipping 22 matching lines @@
       // call checked that the manifest covers the current architecture.
       DCHECK(false);
     }
   }
 
   const Json::Value& isa_spec = dictionary[chosen_isa];
   // If the PNaCl debug flag is turned on, look for pnacl-debug entries first.
   // If found, mark that it is a debug URL. Otherwise, fall back to
   // checking for pnacl-translate URLs, etc. and don't mark it as a debug URL.
   if (pnacl_debug_ && isa_spec.isMember(kPnaclDebugKey)) {
-    GrabUrlAndPnaclOptions(isa_spec[kPnaclDebugKey], url, pnacl_options);
-    pnacl_options->set_debug(true);
+    GrabUrlAndPP_PNaClOptions(isa_spec[kPnaclDebugKey], url, pnacl_options);
+    pnacl_options->is_debug = PP_TRUE;
   } else if (isa_spec.isMember(kPnaclTranslateKey)) {
-    GrabUrlAndPnaclOptions(isa_spec[kPnaclTranslateKey], url, pnacl_options);
+    GrabUrlAndPP_PNaClOptions(isa_spec[kPnaclTranslateKey], url, pnacl_options);
   } else {
     // NaCl
     *url = isa_spec[kUrlKey].asString();
-    pnacl_options->set_translate(false);
+    pnacl_options->translate = PP_FALSE;
   }
 
   return true;
 }
 
 bool JsonManifest::GetKeyUrl(const Json::Value& dictionary,
                              const nacl::string& key,
                              nacl::string* full_url,
-                             PnaclOptions* pnacl_options,
+                             PP_PNaClOptions* pnacl_options,
                              ErrorInfo* error_info) const {
   DCHECK(full_url != NULL && pnacl_options != NULL && error_info != NULL);
   if (!dictionary.isMember(key)) {
     error_info->SetReport(PP_NACL_ERROR_MANIFEST_RESOLVE_URL,
                           "file key not found in manifest");
     return false;
   }
   const Json::Value& isa_dict = dictionary[key];
   nacl::string relative_url;
   bool uses_nonsfi_mode;
   if (!GetURLFromISADictionary(isa_dict, key, &relative_url,
                                pnacl_options, &uses_nonsfi_mode, error_info)) {
     return false;
   }
   return ResolveURL(relative_url, full_url, error_info);
 }
 
 bool JsonManifest::GetProgramURL(nacl::string* full_url,
-                                 PnaclOptions* pnacl_options,
+                                 PP_PNaClOptions* pnacl_options,
                                  bool* uses_nonsfi_mode,
                                  ErrorInfo* error_info) const {
   if (full_url == NULL || pnacl_options == NULL || error_info == NULL)
     return false;
 
   const Json::Value& program = dictionary_[kProgramKey];
 
   nacl::string nexe_url;
   nacl::string error_string;
 
@@ skipping 18 matching lines @@
   CHECK(files.isObject());
   Json::Value::Members members = files.getMemberNames();
   for (size_t i = 0; i < members.size(); ++i) {
     keys->insert(members[i]);
   }
   return true;
 }
 
 bool JsonManifest::ResolveKey(const nacl::string& key,
                               nacl::string* full_url,
-                              PnaclOptions* pnacl_options,
+                              PP_PNaClOptions* pnacl_options,
                               ErrorInfo* error_info) const {
   NaClLog(3, "JsonManifest::ResolveKey(%s)\n", key.c_str());
   // key must be one of kProgramKey or kFileKey '/' file-section-key
 
   if (full_url == NULL || pnacl_options == NULL || error_info == NULL)
     return false;
 
   if (key == kProgramKey) {
     return GetKeyUrl(dictionary_, key, full_url, pnacl_options, error_info);
   }
@@ skipping 46 matching lines @@
         "could not resolve url '" + relative_url +
         "' relative to manifest base url '" + manifest_base_url_.c_str() +
         "'.");
     return false;
   }
   *full_url = resolved_url.AsString();
   return true;
 }
 
 }  // namespace plugin