Implementation of URLLoader using PluginResource/ResourceHost.

webkit/plugins/ppapi/ppapi_plugin_instance.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 "webkit/plugins/ppapi/ppapi_plugin_instance.h"
 
 #include "base/bind.h"
 #include "base/callback_helpers.h"
 #include "base/debug/trace_event.h"
 #include "base/logging.h"
@@ skipping 22 matching lines @@
 #include "ppapi/c/private/ppp_instance_private.h"
 #include "ppapi/shared_impl/ppapi_preferences.h"
 #include "ppapi/shared_impl/ppb_gamepad_shared.h"
 #include "ppapi/shared_impl/ppb_input_event_shared.h"
 #include "ppapi/shared_impl/ppb_url_util_shared.h"
 #include "ppapi/shared_impl/ppb_view_shared.h"
 #include "ppapi/shared_impl/ppp_instance_combined.h"
 #include "ppapi/shared_impl/resource.h"
 #include "ppapi/shared_impl/scoped_pp_resource.h"
 #include "ppapi/shared_impl/time_conversion.h"
+#include "ppapi/shared_impl/url_request_info_data.h"
 #include "ppapi/shared_impl/var.h"
 #include "ppapi/thunk/enter.h"
 #include "ppapi/thunk/ppb_buffer_api.h"
 #include "printing/metafile.h"
 #include "printing/metafile_skia_wrapper.h"
 #include "printing/units.h"
 #include "skia/ext/platform_device.h"
 #include "third_party/WebKit/Source/Platform/chromium/public/WebGamepads.h"
 #include "third_party/WebKit/Source/Platform/chromium/public/WebString.h"
 #include "third_party/WebKit/Source/Platform/chromium/public/WebURL.h"
+#include "third_party/WebKit/Source/Platform/chromium/public/WebURLError.h"
 #include "third_party/WebKit/Source/Platform/chromium/public/WebURLRequest.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebBindings.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebCompositionUnderline.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebCursorInfo.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebDocument.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebElement.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebFrame.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebInputEvent.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebPluginContainer.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebPrintParams.h"
@@ skipping 15 matching lines @@
 #include "webkit/plugins/ppapi/fullscreen_container.h"
 #include "webkit/plugins/ppapi/gfx_conversion.h"
 #include "webkit/plugins/ppapi/host_globals.h"
 #include "webkit/plugins/ppapi/message_channel.h"
 #include "webkit/plugins/ppapi/npapi_glue.h"
 #include "webkit/plugins/ppapi/plugin_module.h"
 #include "webkit/plugins/ppapi/plugin_object.h"
 #include "webkit/plugins/ppapi/ppb_buffer_impl.h"
 #include "webkit/plugins/ppapi/ppb_graphics_3d_impl.h"
 #include "webkit/plugins/ppapi/ppb_image_data_impl.h"
-#include "webkit/plugins/ppapi/ppb_url_loader_impl.h"
 #include "webkit/plugins/ppapi/ppp_pdf.h"
 #include "webkit/plugins/ppapi/url_request_info_util.h"
 #include "webkit/plugins/sad_plugin.h"
 
 #if defined(OS_MACOSX)
 #include "printing/metafile_impl.h"
 #endif  // defined(OS_MACOSX)
 
 #if defined(OS_WIN)
 #include "base/metrics/histogram.h"
@@ skipping 28 matching lines @@
 using WebKit::WebDocument;
 using WebKit::WebElement;
 using WebKit::WebFrame;
 using WebKit::WebInputEvent;
 using WebKit::WebPlugin;
 using WebKit::WebPluginContainer;
 using WebKit::WebPrintParams;
 using WebKit::WebPrintScalingOption;
 using WebKit::WebScopedUserGesture;
 using WebKit::WebString;
+using WebKit::WebURLError;
+using WebKit::WebURLLoader;
+using WebKit::WebURLLoaderClient;
 using WebKit::WebURLRequest;
+using WebKit::WebURLResponse;
 using WebKit::WebUserGestureIndicator;
 using WebKit::WebUserGestureToken;
 using WebKit::WebView;
 
 namespace webkit {
 namespace ppapi {
 
 #if defined(OS_WIN)
 // Exported by pdf.dll
 typedef bool (*RenderPDFPageToDCProc)(
@@ skipping 164 matching lines @@
   base::Callback<const void*(const char*)> get_plugin_interface_func =
       base::Bind(&PluginModule::GetPluginInterface, module);
   PPP_Instance_Combined* ppp_instance_combined =
       PPP_Instance_Combined::Create(get_plugin_interface_func);
   if (!ppp_instance_combined)
     return NULL;
   return new PluginInstance(delegate, module, ppp_instance_combined, container,
                             plugin_url);
 }
 
+PluginInstance::NaClDocumentLoader::NaClDocumentLoader()
+    : finished_loading_(false) {
+}
+
+PluginInstance::NaClDocumentLoader::~NaClDocumentLoader(){
+}
+
+void PluginInstance::NaClDocumentLoader::ReplayReceivedData(
+    WebURLLoaderClient* document_loader) {
+  for (std::list<std::string>::iterator it = data_.begin();
+      it != data_.end(); ++it) {
+    document_loader->didReceiveData(NULL, it->c_str(), it->length(),
+                                    0 /* encoded_data_length */);
+  }
+  if (finished_loading_) {
+    document_loader->didFinishLoading(NULL,
+                                      0 /* finish_time */);
+  }
+  if (error_.get()) {
+    document_loader->didFail(NULL, *error_);
+  }
+}
+
+void PluginInstance::NaClDocumentLoader::didReceiveData(
+    WebURLLoader* loader,
+    const char* data,
+    int data_length,
+    int encoded_data_length) {
+  data_.push_back(std::string(data, data_length));
+}
+
+void PluginInstance::NaClDocumentLoader::didFinishLoading(
+    WebURLLoader* loader,
+    double finish_time) {
+  DCHECK(!finished_loading_);
+  finished_loading_ = true;
+}
+
+void PluginInstance::NaClDocumentLoader::didFail(
+    WebURLLoader* loader,
+    const WebURLError& error) {
+  DCHECK(!error_.get());
+  error_.reset(new WebURLError(error));
+}
+
 PluginInstance::GamepadImpl::GamepadImpl(PluginDelegate* delegate)
     : Resource(::ppapi::Resource::Untracked()),
       delegate_(delegate) {
 }
 
 PPB_Gamepad_API* PluginInstance::GamepadImpl::AsPPB_Gamepad_API() {
   return this;
 }
 
 void PluginInstance::GamepadImpl::Sample(PP_Instance /* instance */,
@@ skipping 46 matching lines @@
       message_channel_(NULL),
       sad_plugin_(NULL),
       input_event_mask_(0),
       filtered_input_event_mask_(0),
       text_input_type_(kPluginDefaultTextInputType),
       text_input_caret_(0, 0, 0, 0),
       text_input_caret_bounds_(0, 0, 0, 0),
       text_input_caret_set_(false),
       selection_caret_(0),
       selection_anchor_(0),
-      pending_user_gesture_(0.0) {
+      pending_user_gesture_(0.0),
+      document_loader_(NULL),
+      nacl_document_load_(false) {
   pp_instance_ = HostGlobals::Get()->AddInstance(this);
 
   memset(&current_print_settings_, 0, sizeof(current_print_settings_));
   DCHECK(delegate);
   module_->InstanceCreated(this);
   delegate_->InstanceCreated(this);
   message_channel_.reset(new MessageChannel(this));
 
   view_data_.is_page_visible = delegate->IsPageVisible();
 
   resource_creation_ = delegate_->CreateResourceCreationAPI(this);
+
+  // TODO(bbudge) remove this when the trusted NaCl plugin has been removed.
+  // We must defer certain plugin events for NaCl instances since we switch
+  // from the in-process to the out-of-process proxy after instantiating them.
+  if (module->name() == "Native Client")
+    nacl_document_load_ = true;

[bbudge, 2013/05/08 14:29:49]

If you can think of a better way to detect that this is the NaCl plugin, let me
know. We can't access chrome paths here.

[bbudge, 2013/05/10 00:07:27]

The problem is that this is fragile. We could make it more robust in a few
different ways:
1) Use the name and path from chrome, but we would need to modify DEPS to allow
access to the file.
2) Add a NACL permission. We could then test for it to identify the NaCl plugin.

 }
 
 PluginInstance::~PluginInstance() {
   DCHECK(!fullscreen_container_);
 
   // Force-unbind any Graphics. In the case of Graphics2D, if the plugin
   // leaks the graphics 2D, it may actually get cleaned up after our
   // destruction, so we need its pointers to be up-to-date.
   BindGraphics(pp_instance(), 0);
 
@@ skipping 176 matching lines @@
   scoped_ptr<const char*[]> argv_array(StringVectorToArgArray(argv_));
   bool success =  PP_ToBool(instance_interface_->DidCreate(pp_instance(),
                                                            argn_.size(),
                                                            argn_array.get(),
                                                            argv_array.get()));
   if (success)
     message_channel_->StopQueueingJavaScriptMessages();
   return success;
 }
 
-bool PluginInstance::HandleDocumentLoad(PPB_URLLoader_Impl* loader) {
-  if (!document_loader_)
-    document_loader_ = loader;
-  DCHECK(loader == document_loader_.get());
-
-  return PP_ToBool(instance_interface_->HandleDocumentLoad(
-      pp_instance(), loader->pp_resource()));
+bool PluginInstance::HandleDocumentLoad(
+    const WebKit::WebURLResponse& response) {
+  DCHECK(!document_loader_);
+  if (!nacl_document_load_) {
+    if (module()->is_crashed()) {
+      // Don't create a resource for a crashed plugin.
+      container()->element().document().frame()->stopLoading();
+      return false;
+    }
+    delegate()->HandleDocumentLoad(this, response);
+    // If the load was not abandoned, document_loader_ will now be set. It's
+    // possible that the load was canceled by now and document_loader_ was
+    // already nulled out.
+  } else {
+    // The NaCl proxy isn't available, so save the response and record document
+    // load notifications for later replay.
+    nacl_document_response_ = response;
+    nacl_document_loader_.reset(new NaClDocumentLoader());
+    document_loader_ = nacl_document_loader_.get();
+  }
+  return true;
 }
 
 bool PluginInstance::SendCompositionEventToPlugin(PP_InputEvent_Type type,
                                                   const base::string16& text) {
   std::vector<WebKit::WebCompositionUnderline> empty;
   return SendCompositionEventWithUnderlineInformationToPlugin(
       type, text, empty, static_cast<int>(text.size()),
       static_cast<int>(text.size()));
 }
 
@@ skipping 1822 matching lines @@
     return PP_NACL_ERROR_INSTANCE;
   message_channel_->StopQueueingJavaScriptMessages();
 
   // Clear sent_initial_did_change_view_ and cancel any pending DidChangeView
   // event. This way, SendDidChangeView will send the "current" view
   // immediately (before other events like HandleDocumentLoad).
   sent_initial_did_change_view_ = false;
   view_change_weak_ptr_factory_.InvalidateWeakPtrs();
   SendDidChangeView();
 
-  // If we received HandleDocumentLoad, re-send it now via the proxy.
-  if (document_loader_)
-    HandleDocumentLoad(document_loader_.get());
+  DCHECK(nacl_document_load_);
+  nacl_document_load_ = false;
+  if (!nacl_document_response_.isNull()) {
+    document_loader_ = NULL;
+    // Pass the response to the nwe proxy.
+    HandleDocumentLoad(nacl_document_response_);
+    nacl_document_response_ = WebKit::WebURLResponse();
+    // Replay any document load events we've received through the real loader.
+    nacl_document_loader_->ReplayReceivedData(document_loader_);
+    nacl_document_loader_.reset(NULL);
+  }
+
   return PP_NACL_OK;
 }
 
 bool PluginInstance::IsValidInstanceOf(PluginModule* module) {
   DCHECK(module);
   return module == module_.get() ||
          module == original_module_.get();
 }
 
 void PluginInstance::DoSetCursor(WebCursorInfo* cursor) {
@@ skipping 59 matching lines @@
   screen_size_for_fullscreen_ = gfx::Size();
   WebElement element = container_->element();
   element.setAttribute(WebString::fromUTF8(kWidth), width_before_fullscreen_);
   element.setAttribute(WebString::fromUTF8(kHeight), height_before_fullscreen_);
   element.setAttribute(WebString::fromUTF8(kBorder), border_before_fullscreen_);
   element.setAttribute(WebString::fromUTF8(kStyle), style_before_fullscreen_);
 }
 
 }  // namespace ppapi
 }  // namespace webkit