Update Chrome to pull latest PPAPI with new uses of point and size....

webkit/glue/plugins/pepper_url_loader.cc

 // Copyright (c) 2010 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/glue/plugins/pepper_url_loader.h"
 
 #include "base/logging.h"
 #include "third_party/ppapi/c/pp_completion_callback.h"
 #include "third_party/ppapi/c/pp_errors.h"
 #include "third_party/ppapi/c/ppb_url_loader.h"
@@ skipping 37 matching lines @@
 
 bool IsURLLoader(PP_Resource resource) {
   return !!Resource::GetAs<URLLoader>(resource).get();
 }
 
 int32_t Open(PP_Resource loader_id,
              PP_Resource request_id,
              PP_CompletionCallback callback) {
   scoped_refptr<URLLoader> loader(Resource::GetAs<URLLoader>(loader_id));
   if (!loader.get())
-    return PP_Error_BadResource;
+    return PP_ERROR_BADRESOURCE;
 
   scoped_refptr<URLRequestInfo> request(
       Resource::GetAs<URLRequestInfo>(request_id));
   if (!request.get())
-    return PP_Error_BadResource;
+    return PP_ERROR_BADRESOURCE;
 
   return loader->Open(request, callback);
 }
 
 int32_t FollowRedirect(PP_Resource loader_id,
                        PP_CompletionCallback callback) {
   scoped_refptr<URLLoader> loader(Resource::GetAs<URLLoader>(loader_id));
   if (!loader.get())
-    return PP_Error_BadResource;
+    return PP_ERROR_BADRESOURCE;
 
   return loader->FollowRedirect(callback);
 }
 
 bool GetUploadProgress(PP_Resource loader_id,
                        int64_t* bytes_sent,
                        int64_t* total_bytes_to_be_sent) {
   scoped_refptr<URLLoader> loader(Resource::GetAs<URLLoader>(loader_id));
   if (!loader.get())
     return false;
@@ skipping 27 matching lines @@
 
   return response_info->GetResource();
 }
 
 int32_t ReadResponseBody(PP_Resource loader_id,
                          char* buffer,
                          int32_t bytes_to_read,
                          PP_CompletionCallback callback) {
   scoped_refptr<URLLoader> loader(Resource::GetAs<URLLoader>(loader_id));
   if (!loader.get())
-    return PP_Error_BadResource;
+    return PP_ERROR_BADRESOURCE;
 
   return loader->ReadResponseBody(buffer, bytes_to_read, callback);
 }
 
 void Close(PP_Resource loader_id) {
   scoped_refptr<URLLoader> loader(Resource::GetAs<URLLoader>(loader_id));
   if (!loader.get())
     return;
 
   loader->Close();
@@ skipping 27 matching lines @@
 }
 
 // static
 const PPB_URLLoader* URLLoader::GetInterface() {
   return &ppb_urlloader;
 }
 
 int32_t URLLoader::Open(URLRequestInfo* request,
                         PP_CompletionCallback callback) {
   if (loader_.get())
-    return PP_Error_InProgress;
+    return PP_ERROR_INPROGRESS;
 
   // We only support non-blocking calls.
   if (!callback.func)
-    return PP_Error_BadArgument;
+    return PP_ERROR_BADARGUMENT;
 
   WebURLRequest web_request(request->web_request());
 
   WebFrame* frame = instance_->container()->element().document().frame();
   if (!frame)
-    return PP_Error_Failed;
+    return PP_ERROR_FAILED;
   web_request.setURL(
       frame->document().completeURL(WebString::fromUTF8(request->url())));
   frame->setReferrerForRequest(web_request, WebURL());  // Use default.
   frame->dispatchWillSendRequest(web_request);
 
   loader_.reset(WebKit::webKitClient()->createURLLoader());
   if (!loader_.get()) {
     loader_.reset();
-    return PP_Error_Failed;
+    return PP_ERROR_FAILED;
   }
   loader_->loadAsynchronously(web_request, this);
 
   pending_callback_ = callback;
 
   // Notify completion when we receive a redirect or response headers.
-  return PP_Error_WouldBlock;
+  return PP_ERROR_WOULDBLOCK;
 }
 
 int32_t URLLoader::FollowRedirect(PP_CompletionCallback callback) {
   NOTIMPLEMENTED();  // TODO(darin): Implement me.
-  return PP_Error_Failed;
+  return PP_ERROR_FAILED;
 }
 
 int32_t URLLoader::ReadResponseBody(char* buffer, int32_t bytes_to_read,
                                     PP_CompletionCallback callback) {
   if (bytes_to_read <= 0 || !buffer)
-    return PP_Error_BadArgument;
+    return PP_ERROR_BADARGUMENT;
   if (pending_callback_.func)
-    return PP_Error_InProgress;
+    return PP_ERROR_INPROGRESS;
 
   // We only support non-blocking calls.
   if (!callback.func)
-    return PP_Error_BadArgument;
+    return PP_ERROR_BADARGUMENT;
 
   user_buffer_ = buffer;
   user_buffer_size_ = bytes_to_read;
 
   if (!buffer_.empty())
     return FillUserBuffer();
 
   pending_callback_ = callback;
-  return PP_Error_WouldBlock;
+  return PP_ERROR_WOULDBLOCK;
 }
 
 void URLLoader::Close() {
   NOTIMPLEMENTED();  // TODO(darin): Implement me.
 }
 
 void URLLoader::willSendRequest(WebURLLoader* loader,
                                 WebURLRequest& new_request,
                                 const WebURLResponse& redirect_response) {
   NOTIMPLEMENTED();  // TODO(darin): Allow the plugin to inspect redirects.
@@ skipping 23 matching lines @@
     DCHECK(!pending_callback_.func);
   }
 }
 
 void URLLoader::didFinishLoading(WebURLLoader* loader) {
   RunCallback(PP_OK);
 }
 
 void URLLoader::didFail(WebURLLoader* loader, const WebURLError& error) {
   // TODO(darin): Provide more detailed error information.
-  RunCallback(PP_Error_Failed);
+  RunCallback(PP_ERROR_FAILED);
 }
 
 void URLLoader::RunCallback(int32_t result) {
   if (!pending_callback_.func)
     return;
 
   PP_CompletionCallback callback = {0};
   std::swap(callback, pending_callback_);
   PP_RunCompletionCallback(&callback, result);
 }
 
 size_t URLLoader::FillUserBuffer() {
   DCHECK(user_buffer_);
   DCHECK(user_buffer_size_);
 
   size_t bytes_to_copy = std::min(buffer_.size(), user_buffer_size_);
   std::copy(buffer_.begin(), buffer_.begin() + bytes_to_copy, user_buffer_);
   buffer_.erase(buffer_.begin(), buffer_.begin() + bytes_to_copy);
 
   // Reset for next time.
   user_buffer_ = NULL;
   user_buffer_size_ = 0;
   return bytes_to_copy;
 }
 
 }  // namespace pepper