PPAPI: Remove PPB_Font_Dev.

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 <algorithm>
 #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/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 "ppapi/cpp/text_input_controller.h"
+#include "ppapi/cpp/trusted/browser_font_trusted.h"
 
 namespace {
 
 // Extracted from: ui/events/keycodes/keyboard_codes.h
 enum {
   VKEY_BACK = 0x08,
   VKEY_SHIFT = 0x10,
   VKEY_DELETE = 0x2E,
   VKEY_LEFT = 0x25,
   VKEY_UP = 0x26,
@@ skipping 22 matching lines @@
   }
 }
 
 void FillRect(pp::ImageData* image, const pp::Rect& rect, uint32_t color) {
   FillRect(image, rect.x(), rect.y(), rect.width(), rect.height(), color);
 }
 
 size_t GetPrevCharOffsetUtf8(const std::string& str, size_t current_pos) {
   size_t i = current_pos;
   if (i > 0) {
-    do
+    do {
       --i;
-    while (i > 0 && (str[i] & 0xc0) == 0x80);
+    } while (i > 0 && (str[i] & 0xc0) == 0x80);
   }
   return i;
 }
 
 size_t GetNextCharOffsetUtf8(const std::string& str, size_t current_pos) {
   size_t i = current_pos;
   if (i < str.size()) {
-    do
+    do {
       ++i;
-    while (i < str.size() && (str[i] & 0xc0) == 0x80);
+    } while (i < str.size() && (str[i] & 0xc0) == 0x80);
   }
   return i;
 }
 
 size_t GetNthCharOffsetUtf8(const std::string& str, size_t n) {
   size_t i = 0;
   for (size_t step = 0; step < n; ++step)
     i = GetNextCharOffsetUtf8(str, i);
   return i;
 }
@@ skipping 38 matching lines @@
  public:
   MyTextField(pp::Instance* instance, TextFieldStatusHandler* handler,
               int x, int y, int width, int height)
       : instance_(instance),
         status_handler_(handler),
         area_(x, y, width, height),
         font_size_(height - 2),
         caret_pos_(std::string::npos),
         anchor_pos_(std::string::npos),
         target_segment_(0) {
-    pp::FontDescription_Dev desc;
-    desc.set_family(PP_FONTFAMILY_SANSSERIF);
+    pp::BrowserFontDescription desc;
+    desc.set_family(PP_BROWSERFONT_TRUSTED_FAMILY_SANSSERIF);
     desc.set_size(font_size_);
-    font_ = pp::Font_Dev(instance_, desc);
+    font_ = pp::BrowserFont_Trusted(instance_, desc);
   }
 
   // Paint on the specified ImageData.
   void PaintOn(pp::ImageData* image, pp::Rect clip) {
     clip = clip.Intersect(area_);
     FillRect(image, clip, kTextfieldBgColor);
 
     if (caret_pos_ != std::string::npos) {
       int offset = area_.x();
       // selection (for the case without composition text)
       if (composition_.empty() && HasSelection()) {
         int left_x = font_.MeasureSimpleText(
             utf8_text_.substr(0, SelectionLeft()));
         int right_x = font_.MeasureSimpleText(
             utf8_text_.substr(0, SelectionRight()));
         FillRect(image, offset + left_x, area_.y(), right_x - left_x,
                  area_.height(), kTextfieldSelectionBackgroundColor);
       }
       // before caret
       {
         std::string str = utf8_text_.substr(0, caret_pos_);
         font_.DrawTextAt(
             image,
-            pp::TextRun_Dev(str.c_str(), false, false),
+            pp::BrowserFontTextRun(str.c_str(), false, false),
             pp::Point(offset, area_.y() + font_size_),
             kTextfieldTextColor,
             clip,
             false);
         offset += font_.MeasureSimpleText(str);
       }
       // composition
       {
         const std::string& str = composition_;
         // selection
         if (composition_selection_.first != composition_selection_.second) {
           int left_x = font_.MeasureSimpleText(
               str.substr(0, composition_selection_.first));
           int right_x = font_.MeasureSimpleText(
               str.substr(0, composition_selection_.second));
           FillRect(image, offset + left_x, area_.y(), right_x - left_x,
                    area_.height(), kTextfieldSelectionBackgroundColor);
         }
         // composition text
         font_.DrawTextAt(
             image,
-            pp::TextRun_Dev(str.c_str(), false, false),
+            pp::BrowserFontTextRun(str.c_str(), false, false),
             pp::Point(offset, area_.y() + font_size_),
             kTextfieldPreeditTextColor,
             clip,
             false);
         for (size_t i = 0; i < segments_.size(); ++i) {
           size_t l = segments_[i].first;
           size_t r = segments_[i].second;
           if (l != r) {
             int lx = font_.MeasureSimpleText(str.substr(0, l));
             int rx = font_.MeasureSimpleText(str.substr(0, r));
@@ skipping 11 matching lines @@
         FillRect(image,
                  pp::Rect(offset + caretx, area_.y(), 2, area_.height()),
                  kTextfieldCaretColor);
         offset += font_.MeasureSimpleText(str);
       }
       // after caret
       {
         std::string str = utf8_text_.substr(caret_pos_);
         font_.DrawTextAt(
             image,
-            pp::TextRun_Dev(str.c_str(), false, false),
+            pp::BrowserFontTextRun(str.c_str(), false, false),
             pp::Point(offset, area_.y() + font_size_),
             kTextfieldTextColor,
             clip,
             false);
       }
     } else {
       font_.DrawTextAt(
           image,
-          pp::TextRun_Dev(utf8_text_.c_str(), false, false),
+          pp::BrowserFontTextRun(utf8_text_.c_str(), false, false),
           pp::Point(area_.x(), area_.y() + font_size_),
           kTextfieldTextColor,
           clip,
           false);
     }
   }
 
   // Update current composition text.
   void SetComposition(
       const std::string& text,
@@ skipping 41 matching lines @@
   // Handles mouse click event and changes the focus state.
   bool RefocusByMouseClick(int x, int y) {
     if (!Contains(x, y)) {
       // The text field is unfocused.
       caret_pos_ = anchor_pos_ = std::string::npos;
       return false;
     }
 
     // The text field is focused.
     size_t n = font_.CharacterOffsetForPixel(
-        pp::TextRun_Dev(utf8_text_.c_str()), x - area_.x());
+        pp::BrowserFontTextRun(utf8_text_.c_str()), x - area_.x());
     caret_pos_ = anchor_pos_ = GetNthCharOffsetUtf8(utf8_text_, n);
     CaretPosChanged();
     return true;
   }
 
   void MouseDrag(int x, int y) {
     if (!Focused())
       return;
     size_t n = font_.CharacterOffsetForPixel(
-        pp::TextRun_Dev(utf8_text_.c_str()), x - area_.x());
+        pp::BrowserFontTextRun(utf8_text_.c_str()), x - area_.x());
     caret_pos_ = GetNthCharOffsetUtf8(utf8_text_, n);
   }
 
   void MouseUp(int x, int y) {
     if (!Focused())
       return;
     CaretPosChanged();
   }
 
   void KeyLeft(bool shift) {
@@ skipping 72 matching lines @@
   }
   bool HasSelection() const {
     return caret_pos_ != anchor_pos_;
   }
 
   pp::Instance* instance_;
   TextFieldStatusHandler* status_handler_;
 
   pp::Rect area_;
   int font_size_;
-  pp::Font_Dev font_;
+  pp::BrowserFont_Trusted font_;
   std::string utf8_text_;
   size_t caret_pos_;
   size_t anchor_pos_;
   std::string composition_;
   std::vector< std::pair<uint32_t, uint32_t> > segments_;
   std::pair<uint32_t, uint32_t> composition_selection_;
   int target_segment_;
 };
 
 class MyInstance : public pp::Instance {
@@ skipping 324 matching lines @@
   }
 };
 
 namespace pp {
 
 Module* CreateModule() {
   return new MyModule();
 }
 
 }  // namespace pp