Chrome side of converting enums to uppercase.

webkit/glue/plugins/pepper_device_context_2d.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_device_context_2d.h"
 
 #include <iterator>
 
 #include "base/logging.h"
 #include "base/message_loop.h"
@@ skipping 106 matching lines @@
   if (!context.get())
     return false;
   return context->ReplaceContents(image);
 }
 
 int32_t Flush(PP_Resource device_context,
               PP_CompletionCallback callback) {
   scoped_refptr<DeviceContext2D> context(
       Resource::GetAs<DeviceContext2D>(device_context));
   if (!context.get())
-    return PP_Error_BadResource;
+    return PP_ERROR_BADRESOURCE;
   return context->Flush(callback);
 }
 
 const PPB_DeviceContext2D ppb_devicecontext2d = {
   &Create,
   &IsDeviceContext2D,
   &Describe,
   &PaintImageData,
   &Scroll,
   &ReplaceContents,
@@ skipping 135 matching lines @@
   QueuedOperation operation(QueuedOperation::REPLACE);
   operation.replace_image = image_resource;
   queued_operations_.push_back(operation);
 
   return true;
 }
 
 int32_t DeviceContext2D::Flush(const PP_CompletionCallback& callback) {
   // Don't allow more than one pending flush at a time.
   if (HasPendingFlush())
-    return PP_Error_InProgress;
+    return PP_ERROR_INPROGRESS;
 
   // TODO(brettw) check that the current thread is not the main one and
   // implement blocking flushes in this case.
   if (!callback.func)
-    return PP_Error_BadArgument;
+    return PP_ERROR_BADARGUMENT;
 
   gfx::Rect changed_rect;
   for (size_t i = 0; i < queued_operations_.size(); i++) {
     QueuedOperation& operation = queued_operations_[i];
     gfx::Rect op_rect;
     switch (operation.type) {
       case QueuedOperation::PAINT:
         ExecutePaintImageData(operation.paint_image.get(),
                               operation.paint_x, operation.paint_y,
                               operation.paint_src_rect,
@@ skipping 22 matching lines @@
     visible_changed_rect = bound_instance_->clip().Intersect(changed_rect);
 
   if (bound_instance_ && !visible_changed_rect.IsEmpty()) {
     unpainted_flush_callback_.Set(callback);
     bound_instance_->InvalidateRect(visible_changed_rect);
   } else {
     // There's nothing visible to invalidate so just schedule the callback to
     // execute in the next round of the message loop.
     ScheduleOffscreenCallback(FlushCallbackData(callback));
   }
-  return PP_Error_WouldBlock;
+  return PP_ERROR_WOULDBLOCK;
 }
 
 bool DeviceContext2D::ReadImageData(PP_Resource image, int32_t x, int32_t y) {
   // Get and validate the image object to paint into.
   scoped_refptr<ImageData> image_resource(Resource::GetAs<ImageData>(image));
   if (!image_resource.get())
     return false;
   if (image_resource->format() != PP_IMAGEDATAFORMAT_BGRA_PREMUL)
     return false;  // Must be in the right format.
 
@@ skipping 192 matching lines @@
   data.Execute(PP_OK);
 }
 
 bool DeviceContext2D::HasPendingFlush() const {
   return !unpainted_flush_callback_.is_null() ||
          !painted_flush_callback_.is_null() ||
          offscreen_flush_pending_;
 }
 
 }  // namespace pepper