Remove webkit::ppapi::Resource.

webkit/plugins/ppapi/ppb_url_loader_impl.cc

 // Copyright (c) 2011 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/ppb_url_loader_impl.h"
 
 #include "base/logging.h"
 #include "net/base/net_errors.h"
 #include "ppapi/c/pp_completion_callback.h"
 #include "ppapi/c/pp_errors.h"
@@ skipping 11 matching lines @@
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebURLLoader.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebURLLoaderOptions.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebURLRequest.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebURLResponse.h"
 #include "webkit/appcache/web_application_cache_host_impl.h"
 #include "webkit/plugins/ppapi/common.h"
 #include "webkit/plugins/ppapi/plugin_module.h"
 #include "webkit/plugins/ppapi/ppapi_plugin_instance.h"
 #include "webkit/plugins/ppapi/ppb_url_request_info_impl.h"
 #include "webkit/plugins/ppapi/ppb_url_response_info_impl.h"
+#include "webkit/plugins/ppapi/resource_helper.h"
 
 using appcache::WebApplicationCacheHostImpl;
+using ppapi::Resource;
 using ppapi::thunk::EnterResourceNoLock;
 using ppapi::thunk::PPB_URLLoader_API;
 using ppapi::thunk::PPB_URLRequestInfo_API;
 using WebKit::WebFrame;
 using WebKit::WebString;
 using WebKit::WebURL;
 using WebKit::WebURLError;
 using WebKit::WebURLLoader;
 using WebKit::WebURLLoaderOptions;
 using WebKit::WebURLRequest;
 using WebKit::WebURLResponse;
 
 #ifdef _MSC_VER
 // Do not warn about use of std::copy with raw pointers.
 #pragma warning(disable : 4996)
 #endif
 
 namespace webkit {
 namespace ppapi {
 
-PPB_URLLoader_Impl::PPB_URLLoader_Impl(PluginInstance* instance,
+namespace {
+
+WebFrame* GetFrameForResource(const Resource* resource) {
+  PluginInstance* plugin_instance = ResourceHelper::GetPluginInstance(resource);
+  if (!plugin_instance)
+    return NULL;
+  return plugin_instance->container()->element().document().frame();
+}
+
+}  // namespace
+
+PPB_URLLoader_Impl::PPB_URLLoader_Impl(PP_Instance instance,
                                        bool main_document_loader)
     : Resource(instance),
       main_document_loader_(main_document_loader),
       pending_callback_(),
       bytes_sent_(0),
       total_bytes_to_be_sent_(-1),
       bytes_received_(0),
       total_bytes_to_be_received_(-1),
       user_buffer_(NULL),
       user_buffer_size_(0),
@@ skipping 27 matching lines @@
   int32_t rv = ValidateCallback(callback);
   if (rv != PP_OK)
     return rv;
 
   if (request->RequiresUniversalAccess() && !has_universal_access_)
     return PP_ERROR_NOACCESS;
 
   if (loader_.get())
     return PP_ERROR_INPROGRESS;
 
-  WebFrame* frame = instance()->container()->element().document().frame();
+  WebFrame* frame = GetFrameForResource(this);
   if (!frame)
     return PP_ERROR_FAILED;
   WebURLRequest web_request(request->ToWebURLRequest(frame));
 
   WebURLLoaderOptions options;
   if (has_universal_access_) {
     // Universal access allows cross-origin requests and sends credentials.
     options.crossOriginRequestPolicy =
         WebURLLoaderOptions::CrossOriginRequestPolicyAllow;
     options.allowCredentials = true;
@@ skipping 106 matching lines @@
     loader_->setDefersLoading(false);
     is_asynchronous_load_suspended_ = false;
   }
 
   // Wait for didFinishLoading / didFail.
   RegisterCallback(callback);
   return PP_OK_COMPLETIONPENDING;
 }
 
 void PPB_URLLoader_Impl::Close() {
-  if (loader_.get()) {
+  if (loader_.get())
     loader_->cancel();
-  } else if (main_document_loader_) {
-    WebFrame* frame = instance()->container()->element().document().frame();
-    frame->stopLoading();
-  }
+  else if (main_document_loader_)
+    GetFrameForResource(this)->stopLoading();
   // TODO(viettrungluu): Check what happens to the callback (probably the
   // wrong thing). May need to post abort here. crbug.com/69457
 }
 
 void PPB_URLLoader_Impl::GrantUniversalAccess() {
   has_universal_access_ = true;
 }
 
 void PPB_URLLoader_Impl::SetStatusCallback(
     PP_URLLoaderTrusted_StatusCallback cb) {
@@ skipping 110 matching lines @@
   if (pending_callback_.get() && !pending_callback_->completed())
     return PP_ERROR_INPROGRESS;
 
   return PP_OK;
 }
 
 void PPB_URLLoader_Impl::RegisterCallback(PP_CompletionCallback callback) {
   DCHECK(callback.func);
   DCHECK(!pending_callback_.get() || pending_callback_->completed());
 
+  PluginModule* plugin_module = ResourceHelper::GetPluginModule(this);
+  if (!plugin_module)
+    return;
+
   pending_callback_ = new TrackedCompletionCallback(
-      instance()->module()->GetCallbackTracker(), pp_resource(), callback);
+      plugin_module->GetCallbackTracker(), pp_resource(), callback);
 }
 
 void PPB_URLLoader_Impl::RunCallback(int32_t result) {
   // This may be null only when this is a main document loader.
   if (!pending_callback_.get()) {
     CHECK(main_document_loader_);
     return;
   }
 
   scoped_refptr<TrackedCompletionCallback> callback;
@@ skipping 20 matching lines @@
   }
 
   // Reset for next time.
   user_buffer_ = NULL;
   user_buffer_size_ = 0;
   return bytes_to_copy;
 }
 
 void PPB_URLLoader_Impl::SaveResponse(const WebURLResponse& response) {
   scoped_refptr<PPB_URLResponseInfo_Impl> response_info(
-      new PPB_URLResponseInfo_Impl(instance()));
+      new PPB_URLResponseInfo_Impl(pp_instance()));
   if (response_info->Initialize(response))
     response_info_ = response_info;
 }
 
 void PPB_URLLoader_Impl::UpdateStatus() {
   if (status_callback_ &&
       (RecordDownloadProgress() || RecordUploadProgress())) {
     // Here we go through some effort to only send the exact information that
     // the requestor wanted in the request flags. It would be just as
     // efficient to send all of it, but we don't want people to rely on
     // getting download progress when they happen to set the upload progress
     // flag.
     status_callback_(
-        instance()->pp_instance(), pp_resource(),
+        pp_instance(), pp_resource(),
         RecordUploadProgress() ? bytes_sent_ : -1,
         RecordUploadProgress() ?  total_bytes_to_be_sent_ : -1,
         RecordDownloadProgress() ? bytes_received_ : -1,
         RecordDownloadProgress() ? total_bytes_to_be_received_ : -1);
   }
 }
 
 bool PPB_URLLoader_Impl::RecordDownloadProgress() const {
   return request_info_ && request_info_->record_download_progress();
 }
 
 bool PPB_URLLoader_Impl::RecordUploadProgress() const {
   return request_info_ && request_info_->record_upload_progress();
 }
 
 }  // namespace ppapi
 }  // namespace webkit