PPAPI: Move IMEInputEvent and TextInput to stable.

ppapi/examples/ime/ime.cc

 // Copyright (c) 2012 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 <string>
 #include <utility>
 #include <vector>
 
 #include "ppapi/c/dev/ppb_cursor_control_dev.h"
 #include "ppapi/c/ppb_console.h"
 #include "ppapi/cpp/completion_callback.h"
 #include "ppapi/cpp/dev/font_dev.h"
-#include "ppapi/cpp/dev/ime_input_event_dev.h"
-#include "ppapi/cpp/dev/text_input_dev.h"
 #include "ppapi/cpp/graphics_2d.h"
 #include "ppapi/cpp/image_data.h"
+#include "ppapi/cpp/ime_input_event.h"
 #include "ppapi/cpp/input_event.h"
 #include "ppapi/cpp/instance.h"
 #include "ppapi/cpp/module.h"
 #include "ppapi/cpp/rect.h"
 #include "ppapi/cpp/size.h"
+#include "ppapi/cpp/text_input.h"
 
 namespace {
 
 // Extracted from: ui/base/keycodes/keyboard_codes.h
 enum {
   VKEY_BACK = 0x08,
   VKEY_SHIFT = 0x10,
   VKEY_DELETE = 0x2E,
   VKEY_LEFT = 0x25,
   VKEY_UP = 0x26,
@@ skipping 78 matching lines @@
   virtual void FocusOut() {
     textinput_control_.CancelCompositionText();
     textinput_control_.SetTextInputType(PP_TEXTINPUT_TYPE_NONE);
   }
   virtual void UpdateSelection(const std::string& text) {
     textinput_control_.SetSelectionText(text);
     textinput_control_.SelectionChanged();
   }
 
  private:
-  class MyTextInput : public pp::TextInput_Dev {
+  class MyTextInput : public pp::TextInput {
    public:
-    MyTextInput(pp::Instance* instance) : pp::TextInput_Dev(instance) {}
+    MyTextInput(pp::Instance* instance) : pp::TextInput(instance) {}
     virtual void RequestSurroundingText(uint32_t characters) {
       UpdateSurroundingText(selection_text_, 0, selection_text_.size());
     }
     void SetSelectionText(const std::string& text) { selection_text_ = text; }
     std::string selection_text_;
   };
   MyTextInput textinput_control_;
 };
 
 // Hand-made text field for demonstrating text input API.
@@ skipping 288 matching lines @@
     RequestInputEvents(PP_INPUTEVENT_CLASS_MOUSE);
     RequestFilteringInputEvents(PP_INPUTEVENT_CLASS_KEYBOARD);
 
     for (uint32_t i = 0; i < argc; ++i) {
       if (argn[i] == std::string("ime")) {
         if (argv[i] == std::string("no")) {
           // Example of NO-IME plugins (e.g., games).
           //
           // When a plugin never wants to accept text input, at initialization
           // explicitly turn off the text input feature by calling:
-          pp::TextInput_Dev(this).SetTextInputType(PP_TEXTINPUT_TYPE_NONE);
+          pp::TextInput(this).SetTextInputType(PP_TEXTINPUT_TYPE_NONE);
         } else if (argv[i] == std::string("unaware")) {
           // Demonstrating the behavior of IME-unaware plugins.
           // Never call any text input related APIs.
           //
           // In such a case, the plugin is assumed to always accept text input.
           // For example, when the plugin is focused in touch devices a virtual
           // keyboard may pop up, or in environment IME is used, users can type
           // text via IME on the plugin. The characters are delivered to the
           // plugin via PP_INPUTEVENT_TYPE_CHAR events.
         } else if (argv[i] == std::string("caretmove")) {
@@ skipping 53 matching lines @@
         ret = OnKeyDown(keyEvent);
         break;
       }
       case PP_INPUTEVENT_TYPE_CHAR: {
         const pp::KeyboardInputEvent keyEvent(event);
         Log("Char [" + keyEvent.GetCharacterText().AsString() + "]");
         ret = OnChar(keyEvent);
         break;
       }
       case PP_INPUTEVENT_TYPE_IME_COMPOSITION_START: {
-        const pp::IMEInputEvent_Dev imeEvent(event);
+        const pp::IMEInputEvent imeEvent(event);
         Log("CompositionStart [" + imeEvent.GetText().AsString() + "]");
         ret = true;
         break;
       }
       case PP_INPUTEVENT_TYPE_IME_COMPOSITION_UPDATE: {
-        const pp::IMEInputEvent_Dev imeEvent(event);
+        const pp::IMEInputEvent imeEvent(event);
         Log("CompositionUpdate [" + imeEvent.GetText().AsString() + "]");
         ret = OnCompositionUpdate(imeEvent);
         break;
       }
       case PP_INPUTEVENT_TYPE_IME_COMPOSITION_END: {
-        const pp::IMEInputEvent_Dev imeEvent(event);
+        const pp::IMEInputEvent imeEvent(event);
         Log("CompositionEnd [" + imeEvent.GetText().AsString() + "]");
         ret = OnCompositionEnd(imeEvent);
         break;
       }
       case PP_INPUTEVENT_TYPE_IME_TEXT: {
-        const pp::IMEInputEvent_Dev imeEvent(event);
+        const pp::IMEInputEvent imeEvent(event);
         Log("ImeText [" + imeEvent.GetText().AsString() + "]");
         ret = OnImeText(imeEvent);
         break;
       }
       default:
         break;
     }
     if (ret && (dragging_ || event.GetType() != PP_INPUTEVENT_TYPE_MOUSEMOVE))
       Paint();
     return ret;
   }
 
   virtual void DidChangeView(const pp::Rect& position, const pp::Rect& clip) {
     if (position.size() == last_size_)
       return;
     last_size_ = position.size();
     Paint();
   }
 
  private:
-  bool OnCompositionUpdate(const pp::IMEInputEvent_Dev& ev) {
+  bool OnCompositionUpdate(const pp::IMEInputEvent& ev) {
     for (std::vector<MyTextField>::iterator it = textfield_.begin();
          it != textfield_.end();
          ++it) {
       if (it->Focused()) {
         std::vector< std::pair<uint32_t, uint32_t> > segs;
-        for (uint32_t i = 0; i < ev.GetSegmentNumber(); ++i)
+        for (uint32_t i = 0; i < ev.GetSegmentCount(); ++i)
           segs.push_back(std::make_pair(ev.GetSegmentOffset(i),
                                         ev.GetSegmentOffset(i + 1)));
         it->SetComposition(ev.GetText().AsString(),
                            segs,
                            ev.GetTargetSegment(),
                            ev.GetSelection());
         return true;
       }
     }
     return false;
   }
 
-  bool OnCompositionEnd(const pp::IMEInputEvent_Dev& ev) {
+  bool OnCompositionEnd(const pp::IMEInputEvent& ev) {
     for (std::vector<MyTextField>::iterator it = textfield_.begin();
          it != textfield_.end();
          ++it) {
       if (it->Focused()) {
         it->SetComposition(std::string(),
                            std::vector<std::pair<uint32_t, uint32_t> >(),
                            0,
                            std::make_pair(0, 0));
         return true;
       }
@@ skipping 86 matching lines @@
       if (it->Focused()) {
         std::string str = ev.GetCharacterText().AsString();
         if (str != "\r" && str != "\n")
           it->InsertText(str);
         return true;
       }
     }
     return false;
   }
 
-  bool OnImeText(const pp::IMEInputEvent_Dev ev) {
+  bool OnImeText(const pp::IMEInputEvent ev) {
     for (std::vector<MyTextField>::iterator it = textfield_.begin();
          it != textfield_.end();
          ++it) {
       if (it->Focused()) {
         it->InsertText(ev.GetText().AsString());
         return true;
       }
     }
     return false;
   }
@@ skipping 48 matching lines @@
   }
 };
 
 namespace pp {
 
 Module* CreateModule() {
   return new MyModule();
 }
 
 }  // namespace pp