Fix Xaos port

ports/xaos/nacl-ui-driver/ppapi.c

 /*
  * Copyright (c) 2011 The Native Client 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 "aconfig.h"
 
 /*includes */
 #include <stdio.h>
 #include <stdlib.h>
@@ skipping 90 matching lines @@
   /* it is now safe to use the video buffer */
   Video.dirty = 0;
   pthread_mutex_unlock(&Video.flush_mutex);
   ScheduleScreenRefresh();
 }
 
 void CopyImageDataToVideo(void* data) {
   pthread_mutex_lock(&Video.flush_mutex);
   Video.dirty = 1;
   memcpy(Video.image_data, data, Video.width * Video.height * BYTES_PER_PIXEL);
+
+  /* Set alpha to 0xff.  xaos generates zeros here */
+  int* pixels = (int*)Video.image_data;
+  int i;
+  for (i = 0; i < Video.width * Video.height; i++) {
+    pixels[i] |= 0xff000000;
+  }
+
   /* do not let anybody write into video buffer while flush in progress*/
   pthread_mutex_unlock(&Video.flush_mutex);
 }
 
 struct PP_CompletionCallback FlushCallback = {FlushCallbackFun, NULL};
 
 void ScreenUpdateCallbackFun(void* user_data, int32_t result) {
   if (!Video.dirty) {
     ScheduleScreenRefresh();
     return;
   }
 
+  NaClLog(LOG_TRACE, "ScreenUpdateCallbackFun\n");
   pthread_mutex_lock(&Video.flush_mutex);
   struct PP_Point top_left = PP_MakePoint(0, 0);
   Global.if_graphics_2d->PaintImageData(Video.device, Video.image, &top_left,
                                         NULL);
 
   Global.if_graphics_2d->Flush(Video.device, FlushCallback);
 }
 
 struct PP_CompletionCallback ScreenUpdateCallback = {ScreenUpdateCallbackFun,
                                                      NULL};
 
 static void InitEvents() {
   NaClLog(LOG_INFO, "initialize event queue\n");
   pthread_mutex_init(&EventQueue.mutex, NULL);
   pthread_cond_init(&EventQueue.condvar, NULL);
 }
 
 static void InitScreenRefresh(PP_Instance instance,
                               const struct PP_Size* size) {
-  NaClLog(LOG_INFO, "initialize screen refresh\n");
+  NaClLog(LOG_INFO, "initialize screen refresh %dx%d\n", size->width,
+      size->height);
   /* NOTE: these limits are not tight but there seem to be some
      not so well documented limitations inside xaos */
   CHECK(size->width <= 640);
   CHECK(size->height <= 480);
 
   Video.width = size->width;
   Video.height = size->height;
 
   NaClLog(LOG_INFO, "create PPAPI graphics device\n");
-  Video.device = Global.if_graphics_2d->Create(instance, size, PP_FALSE);
+  Video.device = Global.if_graphics_2d->Create(instance, size, PP_TRUE);
   CHECK(Video.device != 0);
   NaClLog(LOG_INFO, "create PPAPI image");
   CHECK(Global.if_instance->BindGraphics(Global.instance, Video.device));
   Video.image = Global.if_image_data->Create(
       instance, PP_IMAGEDATAFORMAT_BGRA_PREMUL, size, PP_TRUE);
   CHECK(Video.image != 0);
   NaClLog(LOG_INFO, "map image into shared memory\n");
   Video.image_data = (void*)Global.if_image_data->Map(Video.image);
   CHECK(Video.image_data != NULL);
   NaClLog(LOG_INFO, "map is %p\n", Video.image_data);
@@ skipping 62 matching lines @@
   Init(instance, &position.size);
 }
 
 static void DidChangeFocus(PP_Instance instance, PP_Bool has_focus) {
   NaClLog(LOG_INFO, "DidChangeFocus\n");
   /* force a refresh */
   Video.dirty = 1;
 }
 
 static PP_Bool HandleInputEvent(PP_Instance instance, PP_Resource input_event) {
-  NaClLog(LOG_INFO, "HandleInputEvent\n");
+  NaClLog(LOG_TRACE, "HandleInputEvent\n");
   if (!Global.if_mouse_input_event->IsMouseInputEvent(input_event)) {
     return PP_FALSE;
   }
 
   // XaoS has problems with Buttons numbered higher than the right button
   if (Global.if_mouse_input_event->GetButton(input_event) > 2) {
     return PP_FALSE;
   }
 
   struct PpapiEvent* event = (struct PpapiEvent*)malloc(sizeof *event);
   event->type = Global.if_input_event->GetType(input_event);
   event->button = Global.if_mouse_input_event->GetButton(input_event);
   event->position = Global.if_mouse_input_event->GetPosition(input_event);
   event->clicks = Global.if_mouse_input_event->GetClickCount(input_event);
 
   pthread_mutex_lock(&EventQueue.mutex);
   if (EventQueue.num >= kMaxEvents) {
     NaClLog(LOG_ERROR, "dropping events because of overflow\n");
   } else {
+    NaClLog(LOG_TRACE, "queue input event\n");
     int head = (EventQueue.tail + EventQueue.num) % kMaxEvents;
     EventQueue.queue[head] = event;
     ++EventQueue.num;
     if (EventQueue.num >= kMaxEvents)
       EventQueue.num -= kMaxEvents;
     pthread_cond_signal(&EventQueue.condvar);
   }
 
   pthread_mutex_unlock(&EventQueue.mutex);
   return PP_TRUE;
@@ skipping 74 matching lines @@
   if (0 == strncmp(PPP_INSTANCE_INTERFACE, interface_name,
                    strlen(PPP_INSTANCE_INTERFACE))) {
     return &GlobalInstanceInterface;
   }
   if (0 == strncmp(PPP_INPUT_EVENT_INTERFACE, interface_name,
                    strlen(PPP_INPUT_EVENT_INTERFACE))) {
     return &GlobalInputEventInterface;
   }
   return NULL;
 }