Revert 284684 "Pepper: Delete FileDownloader in trusted plugin."

trunk/src/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>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/command_line.h"
 #include "base/containers/scoped_ptr_hash_map.h"
 #include "base/cpu.h"
 #include "base/files/file.h"
 #include "base/lazy_instance.h"
 #include "base/logging.h"
 #include "base/rand_util.h"
-#include "base/strings/string_split.h"
-#include "base/strings/string_util.h"
 #include "components/nacl/common/nacl_host_messages.h"
 #include "components/nacl/common/nacl_messages.h"
 #include "components/nacl/common/nacl_nonsfi_util.h"
 #include "components/nacl/common/nacl_switches.h"
 #include "components/nacl/common/nacl_types.h"
 #include "components/nacl/renderer/file_downloader.h"
 #include "components/nacl/renderer/histogram.h"
 #include "components/nacl/renderer/json_manifest.h"
 #include "components/nacl/renderer/manifest_downloader.h"
 #include "components/nacl/renderer/manifest_service_channel.h"
@@ skipping 15 matching lines @@
 #include "net/http/http_util.h"
 #include "ppapi/c/pp_bool.h"
 #include "ppapi/c/private/pp_file_handle.h"
 #include "ppapi/shared_impl/ppapi_globals.h"
 #include "ppapi/shared_impl/ppapi_permissions.h"
 #include "ppapi/shared_impl/ppapi_preferences.h"
 #include "ppapi/shared_impl/var.h"
 #include "ppapi/shared_impl/var_tracker.h"
 #include "ppapi/thunk/enter.h"
 #include "third_party/WebKit/public/platform/WebURLLoader.h"
-#include "third_party/WebKit/public/platform/WebURLResponse.h"
 #include "third_party/WebKit/public/web/WebDocument.h"
 #include "third_party/WebKit/public/web/WebElement.h"
 #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 {
@@ skipping 515 matching lines @@
   if(!sender->Send(new NaClHostMsg_NaClGetNumProcessors(&num_processors))) {
     return 1;
   }
   return num_processors;
 }
 
 PP_Bool PPIsNonSFIModeEnabled() {
   return PP_FromBool(IsNonSFIModeEnabled());
 }
 
-void GetNexeFd(PP_Instance instance,
-               const std::string& pexe_url,
-               uint32_t opt_level,
-               const base::Time& last_modified_time,
-               const std::string& etag,
-               bool has_no_store_header,
-               base::Callback<void(int32_t, bool, PP_FileHandle)> callback) {
-  if (!InitializePnaclResourceHost()) {
-    ppapi::PpapiGlobals::Get()->GetMainThreadMessageLoop()->PostTask(
-    FROM_HERE,
-    base::Bind(callback,
-               static_cast<int32_t>(PP_ERROR_FAILED),
-               false,
-               PP_kInvalidFileHandle));
-    return;
+void GetNexeFdContinuation(scoped_refptr<ppapi::TrackedCallback> callback,
+                           PP_Bool* out_is_hit,
+                           PP_FileHandle* out_handle,
+                           int32_t pp_error,
+                           bool is_hit,
+                           PP_FileHandle handle) {
+  if (pp_error == PP_OK) {
+    *out_is_hit = PP_FromBool(is_hit);
+    *out_handle = handle;
   }
+  callback->PostRun(pp_error);
+}
+
+int32_t GetNexeFd(PP_Instance instance,
+                  const char* pexe_url,
+                  uint32_t abi_version,
+                  uint32_t opt_level,
+                  const char* http_headers_param,
+                  const char* extra_flags,
+                  PP_Bool* is_hit,
+                  PP_FileHandle* handle,
+                  struct PP_CompletionCallback callback) {
+  ppapi::thunk::EnterInstance enter(instance, callback);
+  if (enter.failed())
+    return enter.retval();
+  if (!pexe_url || !is_hit || !handle)
+    return enter.SetResult(PP_ERROR_BADARGUMENT);
+  if (!InitializePnaclResourceHost())
+    return enter.SetResult(PP_ERROR_FAILED);
+
+  std::string http_headers(http_headers_param);
+  net::HttpUtil::HeadersIterator iter(
+      http_headers.begin(), http_headers.end(), "\r\n");
+
+  std::string last_modified;
+  std::string etag;
+  bool has_no_store_header = false;
+  while (iter.GetNext()) {
+    if (StringToLowerASCII(iter.name()) == "last-modified")
+      last_modified = iter.values();
+    if (StringToLowerASCII(iter.name()) == "etag")
+      etag = iter.values();
+    if (StringToLowerASCII(iter.name()) == "cache-control") {
+      net::HttpUtil::ValuesIterator values_iter(
+          iter.values_begin(), iter.values_end(), ',');
+      while (values_iter.GetNext()) {
+        if (StringToLowerASCII(values_iter.value()) == "no-store")
+          has_no_store_header = true;
+      }
+    }
+  }
+
+  base::Time last_modified_time;
+  // If FromString fails, it doesn't touch last_modified_time and we just send
+  // the default-constructed null value.
+  base::Time::FromString(last_modified.c_str(), &last_modified_time);
 
   PnaclCacheInfo cache_info;
   cache_info.pexe_url = GURL(pexe_url);
-  // TODO(dschuff): Get this value from the pnacl json file after it
-  // rolls in from NaCl.
-  cache_info.abi_version = 1;
+  cache_info.abi_version = abi_version;
   cache_info.opt_level = opt_level;
   cache_info.last_modified = last_modified_time;
   cache_info.etag = etag;
   cache_info.has_no_store_header = has_no_store_header;
   cache_info.sandbox_isa = GetSandboxArch();
-  cache_info.extra_flags = GetCpuFeatures();
+  cache_info.extra_flags = std::string(extra_flags);
 
   g_pnacl_resource_host.Get()->RequestNexeFd(
       GetRoutingID(instance),
       instance,
       cache_info,
-      callback);
+      base::Bind(&GetNexeFdContinuation, enter.callback(), is_hit, handle));
+
+  return enter.SetResult(PP_OK_COMPLETIONPENDING);
 }
 
 void ReportTranslationFinished(PP_Instance instance,
                                PP_Bool success,
                                int32_t opt_level,
                                int64_t pexe_size,
                                int64_t compile_time_us) {
   if (success == PP_TRUE) {
     static const int32_t kUnknownOptLevel = 4;
     if (opt_level < 0 || opt_level > 3)
@@ skipping 882 matching lines @@
   DownloadFile(instance, url,
                base::Bind(&DidOpenManifestEntry, out_file_info, callback));
 }
 
 void SetPNaClStartTime(PP_Instance instance) {
   NexeLoadManager* load_manager = GetNexeLoadManager(instance);
   if (load_manager)
     load_manager->set_pnacl_start_time(base::Time::Now());
 }
 
-class PexeDownloader : public blink::WebURLLoaderClient {
- public:
-  PexeDownloader(PP_Instance instance,
-                 scoped_ptr<blink::WebURLLoader> url_loader,
-                 const std::string& pexe_url,
-                 int32_t pexe_opt_level,
-                 const PPP_PexeStreamHandler* stream_handler,
-                 void* stream_handler_user_data)
-      : instance_(instance),
-        url_loader_(url_loader.Pass()),
-        pexe_url_(pexe_url),
-        pexe_opt_level_(pexe_opt_level),
-        stream_handler_(stream_handler),
-        stream_handler_user_data_(stream_handler_user_data),
-        success_(false),
-        expected_content_length_(-1),
-        weak_factory_(this) { }
-
-  void Load(const blink::WebURLRequest& request) {
-    url_loader_->loadAsynchronously(request, this);
-  }
-
- private:
-  virtual void didReceiveResponse(blink::WebURLLoader* loader,
-                                  const blink::WebURLResponse& response) {
-    success_ = (response.httpStatusCode() == 200);
-    if (!success_)
-      return;
-
-    expected_content_length_ = response.expectedContentLength();
-
-    // Defer loading after receiving headers. This is because we may already
-    // have a cached translated nexe, so check for that now.
-    url_loader_->setDefersLoading(true);
-
-    std::string etag = response.httpHeaderField("etag").utf8();
-    std::string last_modified =
-        response.httpHeaderField("last-modified").utf8();
-    base::Time last_modified_time;
-    base::Time::FromString(last_modified.c_str(), &last_modified_time);
-
-    bool has_no_store_header = false;
-    std::string cache_control =
-        response.httpHeaderField("cache-control").utf8();
-
-    std::vector<std::string> values;
-    base::SplitString(cache_control, ',', &values);
-    for (std::vector<std::string>::const_iterator it = values.begin();
-         it != values.end();
-         ++it) {
-      if (StringToLowerASCII(*it) == "no-store")
-        has_no_store_header = true;
-    }
-
-    GetNexeFd(instance_,
-              pexe_url_,
-              pexe_opt_level_,
-              last_modified_time,
-              etag,
-              has_no_store_header,
-              base::Bind(&PexeDownloader::didGetNexeFd,
-                         weak_factory_.GetWeakPtr()));
-  }
-
-  virtual void didGetNexeFd(int32_t pp_error,
-                            bool cache_hit,
-                            PP_FileHandle file_handle) {
-    if (cache_hit) {
-      stream_handler_->DidCacheHit(stream_handler_user_data_, file_handle);
-
-      // We delete the PexeDownloader at this point since we successfully got a
-      // cached, translated nexe.
-      delete this;
-      return;
-    }
-    stream_handler_->DidCacheMiss(stream_handler_user_data_,
-                                  expected_content_length_);
-
-    // No translated nexe was found in the cache, so we should download the
-    // file to start streaming it.
-    url_loader_->setDefersLoading(false);
-  }
-
-  virtual void didReceiveData(blink::WebURLLoader* loader,
-                              const char* data,
-                              int data_length,
-                              int encoded_data_length) {
-    // Stream the data we received to the stream callback.
-    stream_handler_->DidStreamData(stream_handler_user_data_,
-                                   data,
-                                   data_length);
-  }
-
-  virtual void didFinishLoading(blink::WebURLLoader* loader,
-                                double finish_time,
-                                int64_t total_encoded_data_length) {
-    int32_t result = success_ ? PP_OK : PP_ERROR_FAILED;
-    stream_handler_->DidFinishStream(stream_handler_user_data_, result);
-    delete this;
-  }
-
-  virtual void didFail(blink::WebURLLoader* loader,
-                       const blink::WebURLError& error) {
-    success_ = false;
-  }
-
-  PP_Instance instance_;
-  scoped_ptr<blink::WebURLLoader> url_loader_;
-  std::string pexe_url_;
-  int32_t pexe_opt_level_;
-  const PPP_PexeStreamHandler* stream_handler_;
-  void* stream_handler_user_data_;
-  bool success_;
-  int64_t expected_content_length_;
-  base::WeakPtrFactory<PexeDownloader> weak_factory_;
-};
-
-void StreamPexe(PP_Instance instance,
-                const char* pexe_url,
-                int32_t opt_level,
-                const PPP_PexeStreamHandler* handler,
-                void* handler_user_data) {
-  content::PepperPluginInstance* plugin_instance =
-      content::PepperPluginInstance::Get(instance);
-  if (!plugin_instance) {
-    base::MessageLoop::current()->PostTask(
-        FROM_HERE,
-        base::Bind(handler->DidFinishStream,
-                   handler_user_data,
-                   static_cast<int32_t>(PP_ERROR_FAILED)));
-    return;
-  }
-
-  GURL gurl(pexe_url);
-  const blink::WebDocument& document =
-      plugin_instance->GetContainer()->element().document();
-  scoped_ptr<blink::WebURLLoader> url_loader(
-      CreateWebURLLoader(document, gurl));
-  PexeDownloader* downloader = new PexeDownloader(instance,
-                                                  url_loader.Pass(),
-                                                  pexe_url,
-                                                  opt_level,
-                                                  handler,
-                                                  handler_user_data);
-
-  blink::WebURLRequest url_request = CreateWebURLRequest(document, gurl);
-  // Mark the request as requesting a PNaCl bitcode file,
-  // so that component updater can detect this user action.
-  url_request.addHTTPHeaderField(
-      blink::WebString::fromUTF8("Accept"),
-      blink::WebString::fromUTF8("application/x-pnacl, */*"));
-  downloader->Load(url_request);
-}
-
 const PPB_NaCl_Private nacl_interface = {
   &LaunchSelLdr,
   &StartPpapiProxy,
   &UrandomFD,
   &Are3DInterfacesDisabled,
   &BrokerDuplicateHandle,
   &GetReadExecPnaclFd,
   &CreateTemporaryFile,
   &GetNumberOfProcessors,
   &PPIsNonSFIModeEnabled,
+  &GetNexeFd,
   &ReportTranslationFinished,
   &DispatchEvent,
   &ReportLoadSuccess,
   &ReportLoadError,
   &ReportLoadAbort,
   &NexeDidCrash,
   &InstanceCreated,
   &InstanceDestroyed,
   &NaClDebugEnabledForURL,
   &GetSandboxArch,
   &LogToConsole,
   &GetNaClReadyState,
   &GetExitStatus,
   &SetExitStatus,
   &Vlog,
   &InitializePlugin,
   &GetNexeSize,
   &RequestNaClManifest,
   &GetManifestBaseURL,
   &ProcessNaClManifest,
   &DevInterfacesEnabled,
   &ManifestGetProgramURL,
   &GetPNaClResourceInfo,
   &GetCpuFeatureAttrs,
   &PostMessageToJavaScript,
   &DownloadNexe,
   &ReportSelLdrStatus,
   &LogTranslateTime,
   &OpenManifestEntry,
-  &SetPNaClStartTime,
-  &StreamPexe
+  &SetPNaClStartTime
 };
 
 }  // namespace
 
 const PPB_NaCl_Private* GetNaClPrivateInterface() {
   return &nacl_interface;
 }
 
 }  // namespace nacl