Change the DidChangeView update to take a new ViewChanged resource.

ppapi/native_client/tests/earth/pepper_c.c

 /*
  * 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.
  */
 
 /* NaCl Earth demo */
 /* Pepper code in C */
 
 #include "native_client/tests/earth/earth.h"
 
 #include <assert.h>
 #include <stdbool.h>
 #include <stdio.h>
 
 /* Pepper includes */
 #include "ppapi/c/pp_completion_callback.h"
 #include "ppapi/c/pp_errors.h"
 #include "ppapi/c/pp_instance.h"
 #include "ppapi/c/pp_module.h"
 #include "ppapi/c/pp_point.h"
 #include "ppapi/c/pp_rect.h"
 #include "ppapi/c/pp_size.h"
 #include "ppapi/c/ppb_core.h"
 #include "ppapi/c/ppb_graphics_2d.h"
 #include "ppapi/c/ppb_image_data.h"
 #include "ppapi/c/ppb_instance.h"
+#include "ppapi/c/ppb_view.h"
 #include "ppapi/c/ppp.h"
 #include "ppapi/c/ppp_instance.h"
 
 #define NUMBER_OF_IMAGES 2
 
 PPB_GetInterface g_get_browser_interface = NULL;
 
 /* NOTE on PP_Instance: In general Pepper is designed such that a
  * single plugin process can implement multiple plugin instances.
  * This might occur, for example, if a plugin were instantiated by
  * multiple <embed ...> tags in a single page.
  *
  * This implementation assumes at most one instance per plugin,
  * consistent with limitations of the current implementation of
  * Native Client.
  */
 struct PepperState {
   const struct PPB_Core* core_interface;
   const struct PPB_Graphics2D* graphics_2d_interface;
   const struct PPB_ImageData* image_data_interface;
   const struct PPB_Instance* instance_interface;
+  const struct PPB_View* view_interface;
   PP_Resource device_context;
   int32_t which_image;
   PP_Resource image[NUMBER_OF_IMAGES];
   uint32_t* image_data[NUMBER_OF_IMAGES];
   PP_Instance instance;
   struct PP_Rect position;
   bool ready;
 };
 struct PepperState g_MyState;
 bool g_MyStateIsValid = false;
@@ skipping 63 matching lines @@
   if (!device_context) return 0;
 
   if (!g_MyState.instance_interface->BindGraphics(instance, device_context)) {
     g_MyState.core_interface->ReleaseResource(device_context);
     return 0;
   }
   return device_context;
 }
 
 static void Instance_DidChangeView(PP_Instance pp_instance,
-                                   const struct PP_Rect* position,
-                                   const struct PP_Rect* clip) {
+                                   PP_Resource pp_view) {
   DebugPrintf("DidChangeView(%x)\n", pp_instance);
   assert(g_MyStateIsValid == true);
   assert(g_MyState.instance == pp_instance);
 
-  g_MyState.position = *position;
+  g_MyState.view_interface->GetRect(pp_view, &g_MyState.position);
   if (g_MyState.ready == false) {
     g_MyState.device_context =
-      MakeAndBindDeviceContext(pp_instance, &position->size);
+      MakeAndBindDeviceContext(pp_instance, &g_MyState.position.size);
     /* create device context */
     if (!g_MyState.device_context) {
       DebugPrintf("device_context is null!\n");
       return;
     }
     /*
      * Create double-buffered image data.
      * Note: This example does not use transparent pixels. All pixels are
      * written into the framebuffer with alpha set to 255 (opaque)
      * Note: Pepper uses premultiplied alpha.
      */
     g_MyState.which_image = 0;
     for (int i = 0; i < NUMBER_OF_IMAGES; ++i) {
       g_MyState.image[i] =
         g_MyState.image_data_interface->Create(pp_instance,
-          PP_IMAGEDATAFORMAT_BGRA_PREMUL, &position->size, PP_TRUE);
+          PP_IMAGEDATAFORMAT_BGRA_PREMUL, &g_MyState.position.size, PP_TRUE);
       if (!g_MyState.image[i]) {
         DebugPrintf("image resource is invalid!\n");
         return;
       }
       g_MyState.image_data[i] =
         (uint32_t*)g_MyState.image_data_interface->Map(g_MyState.image[i]);
       if (!g_MyState.image_data[i]) {
         DebugPrintf("could not allocate image_data\n");
         return;
       }
-      size_t size_in_bytes = position->size.width * position->size.height *
-                             sizeof(uint32_t);
+      size_t size_in_bytes = g_MyState.position.size.width *
+                             g_MyState.position.size.height * sizeof(uint32_t);
       memset(g_MyState.image_data[i], 0, size_in_bytes);
     }
     g_MyState.ready = true;
     Repaint(&g_MyState);
   }
 }
 
 static void Instance_DidChangeFocus(PP_Instance pp_instance,
                                     PP_Bool has_focus) {
 }
@@ skipping 19 matching lines @@
   g_get_browser_interface = get_browser_interface;
 
   g_MyState.core_interface = (const struct PPB_Core*)
     get_browser_interface(PPB_CORE_INTERFACE);
   g_MyState.instance_interface = (const struct PPB_Instance*)
     get_browser_interface(PPB_INSTANCE_INTERFACE);
   g_MyState.image_data_interface = (const struct PPB_ImageData*)
     get_browser_interface(PPB_IMAGEDATA_INTERFACE);
   g_MyState.graphics_2d_interface = (const struct PPB_Graphics2D*)
     get_browser_interface(PPB_GRAPHICS_2D_INTERFACE);
+  g_MyState.view_interface = (const struct PPB_View*)
+    get_browser_interface(PPB_VIEW_INTERFACE);
   if (!g_MyState.core_interface ||
       !g_MyState.instance_interface ||
       !g_MyState.image_data_interface ||
-      !g_MyState.graphics_2d_interface)
+      !g_MyState.graphics_2d_interface ||
+      !g_MyState.view_interface)
     return -1;
 
   return PP_OK;
 }
 
 PP_EXPORT void PPP_ShutdownModule() {
 }
 
 PP_EXPORT const void* PPP_GetInterface(const char* interface_name) {
   if (strcmp(interface_name, PPP_INSTANCE_INTERFACE) == 0)
     return &instance_interface;
   return NULL;
 }