Fix for checkdeps.

ppapi/examples/ime/ime.cc

 // 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.
 
 #include <string>
 #include <utility>
 #include <vector>
 
-#include "base/memory/scoped_ptr.h"
 #include "ppapi/c/dev/ppb_console_dev.h"
 #include "ppapi/c/dev/ppb_cursor_control_dev.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/input_event.h"
 #include "ppapi/cpp/instance.h"
 #include "ppapi/cpp/module.h"
 #include "ppapi/cpp/rect.h"
 #include "ppapi/cpp/size.h"
-#include "ui/base/keycodes/keyboard_codes.h"
 
 namespace {
 
+// Extracted from: ui/base/keycode/keyboard_codes.h
+enum {
+  VKEY_BACK = 0x08,
+  VKEY_DELETE = 0x2E,
+  VKEY_LEFT = 0x25,
+  VKEY_UP = 0x26,
+  VKEY_RIGHT = 0x27,
+  VKEY_DOWN = 0x28,
+};
+
 const uint32_t kTextfieldBgColor = 0xffffffff;
 const uint32_t kTextfieldTextColor = 0xff000000;
 const uint32_t kTextfieldCaretColor = 0xff000000;
 const uint32_t kTextfieldPreeditTextColor = 0xffff0000;
 const uint32_t kTextfieldUnderlineColorMain = 0xffff0000;
 const uint32_t kTextfieldUnderlineColorSub = 0xffddaaaa;
 
 void FillRect(pp::ImageData* image,
               int left, int top, int width, int height,
               uint32_t color) {
@@ skipping 271 matching lines @@
   int target_segment_;
 };
 
 class MyInstance : public pp::Instance {
  public:
   explicit MyInstance(PP_Instance instance)
       : pp::Instance(instance),
         status_handler_(new TextFieldStatusHandler) {
   }
 
+  ~MyInstance() {
+    delete status_handler_;
+  }
+
   virtual bool Init(uint32_t argc, const char* argn[], const char* argv[]) {
     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);
         } 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")) {
           // Demonstrating the behavior of plugins with limited IME support.
           //
           // It uses SetTextInputType() and UpdateCaretPosition() API to notify
           // text input status to the browser, but unable to handle inline
           // compositions. By using the notified information. the browser can,
           // say, show virtual keyboards or IMEs only at appropriate timing
           // that the plugin does need to accept text input.
-          status_handler_.reset(new TextFieldStatusNotifyingHanlder(this));
+          delete status_handler_;
+          status_handler_ = new TextFieldStatusNotifyingHanlder(this);
         } else if (argv[i] == std::string("full")) {
           // Demonstrating the behavior of plugins fully supporting IME.
           //
           // It notifies updates of caret positions to the browser,
           // and handles all text input events by itself.
-          status_handler_.reset(new TextFieldStatusNotifyingHanlder(this));
+          delete status_handler_;
+          status_handler_ = new TextFieldStatusNotifyingHanlder(this);
           RequestInputEvents(PP_INPUTEVENT_CLASS_IME);
         }
         break;
       }
     }
 
-    textfield_.push_back(MyTextField(this, status_handler_.get(),
+    textfield_.push_back(MyTextField(this, status_handler_,
                                      10, 10, 300, 20));
     textfield_.back().SetText("Hello");
-    textfield_.push_back(MyTextField(this, status_handler_.get(),
+    textfield_.push_back(MyTextField(this, status_handler_,
                                      30, 100, 300, 20));
     textfield_.back().SetText("World");
     return true;
   }
 
  protected:
   virtual bool HandleInputEvent(const pp::InputEvent& event) {
     bool ret = false;
     switch (event.GetType()) {
       case PP_INPUTEVENT_TYPE_MOUSEDOWN: {
@@ skipping 127 matching lines @@
                               0, NULL);
     return true;
   }
 
   bool OnKeyDown(const pp::KeyboardInputEvent& ev) {
     for (std::vector<MyTextField>::iterator it = textfield_.begin();
          it != textfield_.end();
          ++it) {
       if (it->Focused()) {
         switch (ev.GetKeyCode()) {
-          case ui::VKEY_LEFT:
+          case VKEY_LEFT:
             it->KeyLeft();
             break;
-          case ui::VKEY_RIGHT:
+          case VKEY_RIGHT:
             it->KeyRight();
             break;
-          case ui::VKEY_DELETE:
+          case VKEY_DELETE:
             it->KeyDelete();
             break;
-          case ui::VKEY_BACK:
+          case VKEY_BACK:
             it->KeyBackspace();
             break;
         }
         return true;
       }
     }
     return false;
   }
 
   bool OnChar(const pp::KeyboardInputEvent& ev) {
@@ skipping 47 matching lines @@
   // Prints a debug message.
   void Log(const pp::Var& value) {
     const PPB_Console_Dev* console = reinterpret_cast<const PPB_Console_Dev*>(
         pp::Module::Get()->GetBrowserInterface(PPB_CONSOLE_DEV_INTERFACE));
     if (!console)
       return;
     console->Log(pp_instance(), PP_LOGLEVEL_LOG, value.pp_var());
   }
 
   // IME Control interface.
-  scoped_ptr<TextFieldStatusHandler> status_handler_;
+  TextFieldStatusHandler* status_handler_;
 
   // Remembers the size of this instance.
   pp::Size last_size_;
 
   // Holds instances of text fields.
   std::vector<MyTextField> textfield_;
 };
 
 class MyModule : public pp::Module {
   virtual pp::Instance* CreateInstance(PP_Instance instance) {
     return new MyInstance(instance);
   }
 };
 
 namespace pp {
 
 Module* CreateModule() {
   return new MyModule();
 }
 
 }  // namespace pp