Rename NaCl/pepper gamepad interface from _dev to stable

native_client_sdk/src/examples/gamepad/gamepad.cc

 // Copyright (c) 2012 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 "gamepad.h"
 
 #include <stdio.h>
 #include <stdlib.h>
 #include <cassert>
 #include <cmath>
 #include <cstring>
 #include <string>
-#include "ppapi/c/dev/ppb_gamepad_dev.h"
+#include "ppapi/c/ppb_gamepad.h"
 #include "ppapi/cpp/completion_callback.h"
 #include "ppapi/cpp/var.h"
 
 namespace {
 
 // This is called by the browser when the 2D context has been flushed to the
 // browser window.
 void FlushCallback(void* data, int32_t result) {
   static_cast<gamepad::Gamepad*>(data)->set_flush_pending(false);
   static_cast<gamepad::Gamepad*>(data)->Paint();
 }
 
 }  // namespace
 
 namespace gamepad {
 
 Gamepad::Gamepad(PP_Instance instance)
     : pp::Instance(instance),
       graphics_2d_context_(NULL),
       pixel_buffer_(NULL),
       flush_pending_(false),
       quit_(false) {
   pp::Module* module = pp::Module::Get();
   assert(module);
-  gamepad_ = static_cast<const PPB_Gamepad_Dev*>(
-      module->GetBrowserInterface(PPB_GAMEPAD_DEV_INTERFACE));
+  gamepad_ = static_cast<const PPB_Gamepad*>(
+      module->GetBrowserInterface(PPB_GAMEPAD_INTERFACE));
   assert(gamepad_);
 }
 
 Gamepad::~Gamepad() {
   quit_ = true;
   DestroyContext();
   delete pixel_buffer_;
 }
 
 void Gamepad::DidChangeView(const pp::Rect& position,
@@ skipping 27 matching lines @@
          x++)
       *image->GetAddr32(pp::Point(x, y)) = color;
   }
 }
 
 void Gamepad::Paint() {
   // Clear the background.
   FillRect(pixel_buffer_, 0, 0, width(), height(), 0xfff0f0f0);
 
   // Get current gamepad data.
-  PP_GamepadsSampleData_Dev gamepad_data;
+  PP_GamepadsSampleData gamepad_data;
   gamepad_->Sample(pp_instance(), &gamepad_data);
 
   // Draw the current state for each connected gamepad.
   for (size_t p = 0; p < gamepad_data.length; ++p) {
     int width2 = width() / gamepad_data.length / 2;
     int height2 = height() / 2;
     int offset = width2 * 2 * p;
-    PP_GamepadSampleData_Dev& pad = gamepad_data.items[p];
+    PP_GamepadSampleData& pad = gamepad_data.items[p];
 
     if (!pad.connected)
       continue;
 
     // Draw axes.
     for (size_t i = 0; i < pad.axes_length; i += 2) {
       int x = static_cast<int>(pad.axes[i + 0] * width2 + width2) + offset;
       int y = static_cast<int>(pad.axes[i + 1] * height2 + height2);
       uint32_t box_bgra = 0x80000000;  // Alpha 50%.
       FillRect(pixel_buffer_, x - 3, y - 3, 7, 7, box_bgra);
@@ skipping 35 matching lines @@
   // Note that the pixel lock is held while the buffer is copied into the
   // device context and then flushed.
   graphics_2d_context_->PaintImageData(*pixel_buffer_, pp::Point());
   if (flush_pending())
     return;
   set_flush_pending(true);
   graphics_2d_context_->Flush(pp::CompletionCallback(&FlushCallback, this));
 }
 
 }  // namespace gamepad