Pepper: Miscellaneous trusted plugin cleanup.

components/nacl/renderer/ppb_nacl_private_impl.cc

 // Copyright 2013 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 "components/nacl/renderer/ppb_nacl_private_impl.h"
 
 #include <numeric>
 #include <string>
 #include <vector>
 
@@ skipping 42 matching lines @@
 #include "third_party/WebKit/public/web/WebLocalFrame.h"
 #include "third_party/WebKit/public/web/WebPluginContainer.h"
 #include "third_party/WebKit/public/web/WebSecurityOrigin.h"
 #include "third_party/WebKit/public/web/WebURLLoaderOptions.h"
 #include "third_party/jsoncpp/source/include/json/reader.h"
 #include "third_party/jsoncpp/source/include/json/value.h"
 
 namespace nacl {
 namespace {
 
+// The pseudo-architecture used to indicate portable native client.
+const char* const kPortableArch = "portable";
+
 base::LazyInstance<scoped_refptr<PnaclTranslationResourceHost> >
     g_pnacl_resource_host = LAZY_INSTANCE_INITIALIZER;
 
 bool InitializePnaclResourceHost() {
   // Must run on the main thread.
   content::RenderThread* render_thread = content::RenderThread::Get();
   if (!render_thread)
     return false;
   if (!g_pnacl_resource_host.Get()) {
     g_pnacl_resource_host.Get() = new PnaclTranslationResourceHost(
@@ skipping 821 matching lines @@
 
 PP_Var GetManifestURLArgument(PP_Instance instance) {
   nacl::NexeLoadManager* load_manager = GetNexeLoadManager(instance);
   if (load_manager) {
     return ppapi::StringVar::StringToPPVar(
         load_manager->GetManifestURLArgument());
   }
   return PP_MakeUndefined();
 }
 
-PP_Bool IsPNaCl(PP_Instance instance) {
-  nacl::NexeLoadManager* load_manager = GetNexeLoadManager(instance);
-  if (load_manager)
-    return PP_FromBool(load_manager->IsPNaCl());
-  return PP_FALSE;
-}
-
 PP_Bool DevInterfacesEnabled(PP_Instance instance) {
   nacl::NexeLoadManager* load_manager = GetNexeLoadManager(instance);
   if (load_manager)
     return PP_FromBool(load_manager->DevInterfacesEnabled());
   return PP_FALSE;
 }
 
 void DownloadManifestToBufferCompletion(PP_Instance instance,
                                         struct PP_CompletionCallback callback,
                                         struct PP_Var* out_data,
@@ skipping 97 matching lines @@
   }
   callback.func(callback.user_data, pp_error);
 }
 
 int32_t CreatePNaClManifest(PP_Instance /* instance */) {
   return GetPNaClManifestId();
 }
 
 int32_t CreateJsonManifest(PP_Instance instance,
                            const char* manifest_url,
-                           const char* isa_type,
                            const char* manifest_data) {
+  nacl::NexeLoadManager* load_manager = GetNexeLoadManager(instance);
+  if (!load_manager)
+    return -1;
   int32_t manifest_id = g_next_manifest_id.Get();
   g_next_manifest_id.Get()++;
 
+  const char* isa_type;
+  if (load_manager->IsPNaCl())
+    isa_type = kPortableArch;
+  else
+    isa_type = GetSandboxArch();
+
   scoped_ptr<nacl::JsonManifest> j(
       new nacl::JsonManifest(
           manifest_url,
           isa_type,
           PP_ToBool(IsNonSFIModeEnabled()),
           PP_ToBool(NaClDebugEnabledForURL(manifest_url))));
   JsonManifest::ErrorInfo error_info;
   if (j->Init(manifest_data, &error_info)) {
     g_manifest_map.Get().add(manifest_id, j.Pass());
     return manifest_id;
   }
-  nacl::NexeLoadManager* load_manager = GetNexeLoadManager(instance);
-  if (load_manager)
-    load_manager->ReportLoadError(error_info.error, error_info.string);
+  load_manager->ReportLoadError(error_info.error, error_info.string);
   return -1;
 }
 
 void DestroyManifest(PP_Instance /* instance */,
                      int32_t manifest_id) {
   if (manifest_id == GetPNaClManifestId())
     return;
   g_manifest_map.Get().erase(manifest_id);
 }
 
@@ skipping 231 matching lines @@
   &SetExitStatus,
   &Vlog,
   &InitializePlugin,
   &GetNexeSize,
   &RequestNaClManifest,
   &GetManifestBaseURL,
   &ResolvesRelativeToPluginBaseURL,
   &ParseDataURL,
   &ProcessNaClManifest,
   &GetManifestURLArgument,
-  &IsPNaCl,
   &DevInterfacesEnabled,
   &DownloadManifestToBuffer,
   &CreatePNaClManifest,
   &CreateJsonManifest,
   &DestroyManifest,
   &ManifestGetProgramURL,
   &ManifestResolveKey,
   &GetPNaClResourceInfo,
   &GetCpuFeatureAttrs,
   &PostMessageToJavaScript
 };
 
 }  // namespace
 
 const PPB_NaCl_Private* GetNaClPrivateInterface() {
   return &nacl_interface;
 }
 
 }  // namespace nacl