Add C++ wrappers for output parameters.

ppapi/native_client/src/trusted/plugin/plugin.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.
 
 #ifdef _MSC_VER
 // Do not warn about use of std::copy with raw pointers.
 #pragma warning(disable : 4996)
 #endif
 
 #include "native_client/src/trusted/plugin/plugin.h"
@@ skipping 1478 matching lines @@
           callback_factory_.NewCallback(&Plugin::BitcodeDidTranslate);
       // Will always call the callback on success or failure.
       pnacl_coordinator_.reset(
           PnaclCoordinator::BitcodeToNative(this,
                                             program_url,
                                             cache_identity,
                                             translate_callback));
       return;
     } else {
       pp::CompletionCallback open_callback =
-          callback_factory_.NewRequiredCallback(&Plugin::NexeFileDidOpen);
+          callback_factory_.NewCallback(&Plugin::NexeFileDidOpen);
       // Will always call the callback on success or failure.
       CHECK(
           nexe_downloader_.Open(program_url,
                                 DOWNLOAD_TO_FILE,
                                 open_callback,
                                 &UpdateDownloadProgress));
       return;
     }
   }
   // Failed to select the program and/or the translator.
@@ skipping 21 matching lines @@
                  nmf_resolved_url.AsString().c_str()));
   set_manifest_base_url(nmf_resolved_url.AsString());
   set_manifest_url(url);
   // Inform JavaScript that a load is starting.
   set_nacl_ready_state(OPENED);
   EnqueueProgressEvent(kProgressEventLoadStart);
   bool is_data_uri = GetUrlScheme(nmf_resolved_url.AsString()) == SCHEME_DATA;
   HistogramEnumerateManifestIsDataURI(static_cast<int>(is_data_uri));
   if (is_data_uri) {
     pp::CompletionCallback open_callback =
-        callback_factory_.NewRequiredCallback(&Plugin::NaClManifestBufferReady);
+        callback_factory_.NewCallback(&Plugin::NaClManifestBufferReady);
     // Will always call the callback on success or failure.
     CHECK(nexe_downloader_.Open(nmf_resolved_url.AsString(),
                                 DOWNLOAD_TO_BUFFER,
                                 open_callback,
                                 NULL));
   } else {
     pp::CompletionCallback open_callback =
-        callback_factory_.NewRequiredCallback(&Plugin::NaClManifestFileDidOpen);
+        callback_factory_.NewCallback(&Plugin::NaClManifestFileDidOpen);
     // Will always call the callback on success or failure.
     CHECK(nexe_downloader_.Open(nmf_resolved_url.AsString(),
                                 DOWNLOAD_TO_FILE,
                                 open_callback,
                                 NULL));
   }
 }
 
 
 bool Plugin::SetManifestObject(const nacl::string& manifest_json,
@@ skipping 47 matching lines @@
   return file_desc_ok_to_close;
 }
 
 
 bool Plugin::StreamAsFile(const nacl::string& url,
                           PP_CompletionCallback callback) {
   PLUGIN_PRINTF(("Plugin::StreamAsFile (url='%s')\n", url.c_str()));
   FileDownloader* downloader = new FileDownloader();
   downloader->Initialize(this);
   url_downloaders_.insert(downloader);
-  pp::CompletionCallback open_callback =
-      callback_factory_.NewRequiredCallback(
-          &Plugin::UrlDidOpenForStreamAsFile, downloader, callback);
+  pp::CompletionCallback open_callback = callback_factory_.NewCallback(
+      &Plugin::UrlDidOpenForStreamAsFile, downloader, callback);
   // Untrusted loads are always relative to the page's origin.
   CHECK(url_util_ != NULL);
   pp::Var resolved_url =
       url_util_->ResolveRelativeToURL(pp::Var(plugin_base_url()), url);
   if (!resolved_url.is_string()) {
     PLUGIN_PRINTF(("Plugin::StreamAsFile: "
                    "could not resolve url \"%s\" relative to plugin \"%s\".",
                    url.c_str(),
                    plugin_base_url().c_str()));
     return false;
   }
   // If true, will always call the callback on success or failure.
   return downloader->Open(url,
                           DOWNLOAD_TO_FILE,
                           open_callback,
                           &UpdateDownloadProgress);
 }
 
 #ifndef HACK_FOR_MACOS_HANG_REMOVED
 // The following is needed to avoid a plugin startup hang in the
 // MacOS "chrome_browser_tests under gyp" stage.
 // TODO(sehr,mseaborn): remove this hack.
 void (plugin::Plugin::*pmem)(int32_t,
                              plugin::FileDownloader*&,
                              pp::VarPrivate&);
 void Plugin::XYZZY(const nacl::string& url,
                            pp::VarPrivate js_callback) {
   UNREFERENCED_PARAMETER(url);
   UNREFERENCED_PARAMETER(js_callback);
-  pp::CompletionCallback open_callback =
-      callback_factory_.NewRequiredCallback(pmem,
-          reinterpret_cast<plugin::FileDownloader*>(NULL),
-          js_callback);
+  pp::CompletionCallback open_callback = callback_factory_.NewCallback(pmem,
+      reinterpret_cast<plugin::FileDownloader*>(NULL),
+      js_callback);
   static_cast<void>(open_callback);
 }
 #endif  // HACK_FOR_MACOS_HANG_REMOVED
 
 
 void Plugin::ReportLoadSuccess(LengthComputable length_computable,
                                uint64_t loaded_bytes,
                                uint64_t total_bytes) {
   // Set the readyState attribute to indicate loaded.
   set_nacl_ready_state(DONE);
@@ skipping 254 matching lines @@
                                           static_cast<uint32_t>(text.size()));
   const PPB_Console_Dev* console_interface =
       static_cast<const PPB_Console_Dev*>(
           module->GetBrowserInterface(PPB_CONSOLE_DEV_INTERFACE));
   console_interface->LogWithSource(pp_instance(), PP_LOGLEVEL_LOG, prefix, str);
   var_interface->Release(prefix);
   var_interface->Release(str);
 }
 
 }  // namespace plugin