Make PPAPI headers compile with C compilers (gcc on Linux & Mac and MSVS on W...

webkit/glue/plugins/pepper_plugin_instance.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_plugin_instance.h"
 
 #include "base/logging.h"
 #include "base/metrics/histogram.h"
 #if defined(OS_MACOSX)
 #include "base/mac_util.h"
@@ skipping 30 matching lines @@
 #include "third_party/WebKit/WebKit/chromium/public/WebDocument.h"
 #include "third_party/WebKit/WebKit/chromium/public/WebElement.h"
 #include "third_party/WebKit/WebKit/chromium/public/WebFrame.h"
 #include "third_party/WebKit/WebKit/chromium/public/WebInputEvent.h"
 #include "third_party/WebKit/WebKit/chromium/public/WebPluginContainer.h"
 #include "third_party/WebKit/WebKit/chromium/public/WebRect.h"
 #include "third_party/WebKit/WebKit/chromium/public/WebString.h"
 #include "third_party/WebKit/WebKit/chromium/public/WebURLRequest.h"
 #include "third_party/WebKit/WebKit/chromium/public/WebView.h"
 #include "webkit/glue/plugins/pepper_buffer.h"
+#include "webkit/glue/plugins/pepper_common.h"
 #include "webkit/glue/plugins/pepper_graphics_2d.h"
 #include "webkit/glue/plugins/pepper_event_conversion.h"
 #include "webkit/glue/plugins/pepper_fullscreen_container.h"
 #include "webkit/glue/plugins/pepper_image_data.h"
 #include "webkit/glue/plugins/pepper_plugin_delegate.h"
 #include "webkit/glue/plugins/pepper_plugin_module.h"
 #include "webkit/glue/plugins/pepper_string.h"
 #include "webkit/glue/plugins/pepper_url_loader.h"
 #include "webkit/glue/plugins/pepper_var.h"
 #include "webkit/glue/plugins/ppp_private.h"
@@ skipping 92 matching lines @@
   return instance->GetWindowObject();
 }
 
 PP_Var GetOwnerElementObject(PP_Instance instance_id) {
   PluginInstance* instance = ResourceTracker::Get()->GetInstance(instance_id);
   if (!instance)
     return PP_MakeUndefined();
   return instance->GetOwnerElementObject();
 }
 
-bool BindGraphics(PP_Instance instance_id, PP_Resource device_id) {
+PP_Bool BindGraphics(PP_Instance instance_id, PP_Resource device_id) {
   PluginInstance* instance = ResourceTracker::Get()->GetInstance(instance_id);
   if (!instance)
-    return false;
-  return instance->BindGraphics(device_id);
+    return PP_FALSE;
+  return BoolToPPBool(instance->BindGraphics(device_id));
 }
 
-bool IsFullFrame(PP_Instance instance_id) {
+PP_Bool IsFullFrame(PP_Instance instance_id) {
   PluginInstance* instance = ResourceTracker::Get()->GetInstance(instance_id);
   if (!instance)
-    return false;
-  return instance->full_frame();
+    return PP_FALSE;
+  return BoolToPPBool(instance->full_frame());
 }
 
 PP_Var ExecuteScript(PP_Instance instance_id,
                      PP_Var script,
                      PP_Var* exception) {
   PluginInstance* instance = ResourceTracker::Get()->GetInstance(instance_id);
   if (!instance)
     return PP_MakeUndefined();
   return instance->ExecuteScript(script, exception);
 }
 
 const PPB_Instance ppb_instance = {
   &GetWindowObject,
   &GetOwnerElementObject,
   &BindGraphics,
   &IsFullFrame,
   &ExecuteScript,
 };
 
 void NumberOfFindResultsChanged(PP_Instance instance_id,
                                 int32_t total,
-                                bool final_result) {
+                                PP_Bool final_result) {
   PluginInstance* instance = ResourceTracker::Get()->GetInstance(instance_id);
   if (!instance)
     return;
 
   DCHECK_NE(instance->find_identifier(), -1);
   instance->delegate()->NumberOfFindResultsChanged(
-      instance->find_identifier(), total, final_result);
+      instance->find_identifier(), total, PPBoolToBool(final_result));
 }
 
 void SelectedFindResultChanged(PP_Instance instance_id,
                                int32_t index) {
   PluginInstance* instance = ResourceTracker::Get()->GetInstance(instance_id);
   if (!instance)
     return;
 
   DCHECK_NE(instance->find_identifier(), -1);
   instance->delegate()->SelectedFindResultChanged(
       instance->find_identifier(), index);
 }
 
 const PPB_Find_Dev ppb_find = {
   &NumberOfFindResultsChanged,
   &SelectedFindResultChanged,
 };
 
-bool IsFullscreen(PP_Instance instance_id) {
+PP_Bool IsFullscreen(PP_Instance instance_id) {
   PluginInstance* instance = ResourceTracker::Get()->GetInstance(instance_id);
   if (!instance)
-    return false;
-  return instance->IsFullscreen();
+    return PP_FALSE;
+  return BoolToPPBool(instance->IsFullscreen());
 }
 
-bool SetFullscreen(PP_Instance instance_id, bool fullscreen) {
+PP_Bool SetFullscreen(PP_Instance instance_id, PP_Bool fullscreen) {
   PluginInstance* instance = ResourceTracker::Get()->GetInstance(instance_id);
   if (!instance)
-    return false;
-  return instance->SetFullscreen(fullscreen);
+    return PP_FALSE;
+  return BoolToPPBool(instance->SetFullscreen(PPBoolToBool(fullscreen)));
 }
 
 const PPB_Fullscreen_Dev ppb_fullscreen = {
   &IsFullscreen,
   &SetFullscreen,
 };
 
 void ZoomChanged(PP_Instance instance_id, double factor) {
   PluginInstance* instance = ResourceTracker::Get()->GetInstance(instance_id);
   if (!instance)
@@ skipping 251 matching lines @@
 
   size_t argc = 0;
   scoped_array<const char*> argn(new const char*[arg_names.size()]);
   scoped_array<const char*> argv(new const char*[arg_names.size()]);
   for (size_t i = 0; i < arg_names.size(); ++i) {
     argn[argc] = arg_names[i].c_str();
     argv[argc] = arg_values[i].c_str();
     argc++;
   }
 
-  return instance_interface_->DidCreate(pp_instance(),
-                                        argc, argn.get(), argv.get());
+  return PPBoolToBool(instance_interface_->DidCreate(pp_instance(),
+                                                     argc,
+                                                     argn.get(),
+                                                     argv.get()));
 }
 
 bool PluginInstance::HandleDocumentLoad(URLLoader* loader) {
   Resource::ScopedResourceId resource(loader);
-  return instance_interface_->HandleDocumentLoad(pp_instance(), resource.id);
+  return PPBoolToBool(instance_interface_->HandleDocumentLoad(pp_instance(),
+                                                              resource.id));
 }
 
 bool PluginInstance::HandleInputEvent(const WebKit::WebInputEvent& event,
                                       WebCursorInfo* cursor_info) {
   std::vector<PP_InputEvent> pp_events;
   CreatePPEvent(event, &pp_events);
 
   // Each input event may generate more than one PP_InputEvent.
   bool rv = false;
-  for (size_t i = 0; i < pp_events.size(); i++)
-    rv |= instance_interface_->HandleInputEvent(pp_instance(), &pp_events[i]);
+  for (size_t i = 0; i < pp_events.size(); i++) {
+    rv |= PPBoolToBool(instance_interface_->HandleInputEvent(pp_instance(),
+                                                             &pp_events[i]));
+  }
 
   if (cursor_.get())
     *cursor_info = *cursor_;
   return rv;
 }
 
 PP_Var PluginInstance::GetInstanceObject() {
   return instance_interface_->GetInstanceObject(pp_instance());
 }
 
@@ skipping 15 matching lines @@
   RectToPPRect(clip_, &pp_clip);
   instance_interface_->DidChangeView(pp_instance(), &pp_position, &pp_clip);
 }
 
 void PluginInstance::SetWebKitFocus(bool has_focus) {
   if (has_webkit_focus_ == has_focus)
     return;
 
   bool old_plugin_focus = PluginHasFocus();
   has_webkit_focus_ = has_focus;
-  if (PluginHasFocus() != old_plugin_focus)
-    instance_interface_->DidChangeFocus(pp_instance(), PluginHasFocus());
+  if (PluginHasFocus() != old_plugin_focus) {
+    instance_interface_->DidChangeFocus(pp_instance(),
+                                        BoolToPPBool(PluginHasFocus()));
+  }
 }
 
 void PluginInstance::SetContentAreaFocus(bool has_focus) {
   if (has_content_area_focus_ == has_focus)
     return;
 
   bool old_plugin_focus = PluginHasFocus();
   has_content_area_focus_ = has_focus;
-  if (PluginHasFocus() != old_plugin_focus)
-    instance_interface_->DidChangeFocus(pp_instance(), PluginHasFocus());
+  if (PluginHasFocus() != old_plugin_focus) {
+    instance_interface_->DidChangeFocus(pp_instance(),
+                                        BoolToPPBool(PluginHasFocus()));
+  }
 }
 
 void PluginInstance::ViewInitiatedPaint() {
   if (bound_graphics_2d_)
     bound_graphics_2d_->ViewInitiatedPaint();
 }
 
 void PluginInstance::ViewFlushedPaint() {
   if (bound_graphics_2d_)
     bound_graphics_2d_->ViewFlushedPaint();
@@ skipping 23 matching lines @@
   *dib = image_data->platform_image()->GetTransportDIB();
   *location = plugin_backing_store_rect;
   *clip = clip_;
   return true;
 }
 
 string16 PluginInstance::GetSelectedText(bool html) {
   if (!LoadSelectionInterface())
     return string16();
 
-  PP_Var rv = plugin_selection_interface_->GetSelectedText(pp_instance(), html);
+  PP_Var rv = plugin_selection_interface_->GetSelectedText(pp_instance(),
+                                                           BoolToPPBool(html));
   scoped_refptr<StringVar> string(StringVar::FromPPVar(rv));
   Var::PluginReleasePPVar(rv);  // Release the ref the plugin transfered to us.
   if (!string)
     return string16();
   return UTF8ToUTF16(string->value());
 }
 
 string16 PluginInstance::GetLinkAtPosition(const gfx::Point& point) {
   if (!LoadPrivateInterface())
     return string16();
 
   PP_Point p;
   p.x = point.x();
   p.y = point.y();
   PP_Var rv = plugin_private_interface_->GetLinkAtPosition(pp_instance(), p);
   scoped_refptr<StringVar> string(StringVar::FromPPVar(rv));
   Var::PluginReleasePPVar(rv);  // Release the ref the plugin transfered to us.
   if (!string)
     return string16();
   return UTF8ToUTF16(string->value());
 }
 
 void PluginInstance::Zoom(double factor, bool text_only) {
   if (!LoadZoomInterface())
     return;
-  plugin_zoom_interface_->Zoom(pp_instance(), factor, text_only);
+  plugin_zoom_interface_->Zoom(pp_instance(), factor, BoolToPPBool(text_only));
 }
 
 bool PluginInstance::StartFind(const string16& search_text,
                                bool case_sensitive,
                                int identifier) {
   if (!LoadFindInterface())
     return false;
   find_identifier_ = identifier;
-  return plugin_find_interface_->StartFind(
-      pp_instance(),
-      UTF16ToUTF8(search_text.c_str()).c_str(),
-      case_sensitive);
+  return PPBoolToBool(
+      plugin_find_interface_->StartFind(
+          pp_instance(),
+          UTF16ToUTF8(search_text.c_str()).c_str(),
+          BoolToPPBool(case_sensitive)));
 }
 
 void PluginInstance::SelectFindResult(bool forward) {
   if (LoadFindInterface())
-    plugin_find_interface_->SelectFindResult(pp_instance(), forward);
+    plugin_find_interface_->SelectFindResult(pp_instance(),
+                                             BoolToPPBool(forward));
 }
 
 void PluginInstance::StopFind() {
   if (!LoadFindInterface())
     return;
   find_identifier_ = -1;
   plugin_find_interface_->StopFind(pp_instance());
 }
 
 bool PluginInstance::LoadFindInterface() {
@@ skipping 85 matching lines @@
     // PrintBegin should not have been called since SupportsPrintInterface
     // would have returned false;
     NOTREACHED();
     return 0;
   }
 
   PP_PrintSettings_Dev print_settings;
   RectToPPRect(printable_area, &print_settings.printable_area);
   print_settings.dpi = printer_dpi;
   print_settings.orientation = PP_PRINTORIENTATION_NORMAL;
-  print_settings.grayscale = false;
+  print_settings.grayscale = PP_FALSE;
   print_settings.format = format;
   int num_pages = plugin_print_interface_->Begin(pp_instance(),
                                                  &print_settings);
   if (!num_pages)
     return 0;
   current_print_settings_ = print_settings;
 #if defined (OS_LINUX)
   num_pages_ = num_pages;
   pdf_output_done_ = false;
 #endif  // (OS_LINUX)
@@ skipping 325 matching lines @@
   bounds.size.width = dest_rect.width();
   bounds.size.height = dest_rect.height();
 
   CGContextDrawImage(canvas, bounds, image);
   CGContextRestoreGState(canvas);
 }
 #endif  // defined(OS_MACOSX)
 
 
 }  // namespace pepper