Add spellcheck and word suggestion to the prediction service

services/keyboard_native/key_layout.cc

 // Copyright 2015 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 "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/macros.h"
 #include "mojo/tools/embed/data.h"
 #include "services/keyboard_native/kActionIcon.h"
 #include "services/keyboard_native/kDeleteIcon.h"
 #include "services/keyboard_native/kLowerCaseIcon.h"
 #include "services/keyboard_native/kUpperCaseIcon.h"
 #include "services/keyboard_native/key_layout.h"
+#include "services/keyboard_native/predictor.h"
+#include "services/keyboard_native/text_update_key.h"
 #include "skia/ext/refptr.h"
 #include "third_party/skia/include/core/SkCanvas.h"
 #include "third_party/skia/include/core/SkImageDecoder.h"
 #include "third_party/skia/include/core/SkStream.h"
 #include "third_party/skia/include/core/SkTypeface.h"
 #include "ui/gfx/codec/png_codec.h"
 #include "ui/gfx/geometry/point_f.h"
 #include "ui/gfx/shadow_value.h"
 #include "ui/gfx/skia_util.h"
 #include "ui/gfx/vector2d.h"
@@ skipping 72 matching lines @@
  private:
   KeyLayout::TextKey text_key_;
   bool bitmap_valid_;
   SkBitmap bitmap_;
 
   DISALLOW_COPY_AND_ASSIGN(ImageKey);
 };
 
 KeyLayout::KeyLayout()
     : on_text_callback_(),
+      on_suggest_text_callback_(),
       layout_(&letters_layout_),
       key_map_(&lower_case_key_map_),
+      predictor_(nullptr),
       weak_factory_(this) {
   InitLayouts();
   InitKeyMaps();
 }
 
 KeyLayout::~KeyLayout() {
   for (auto& row : lower_case_key_map_) {
     for (auto& key : row) {
       delete key;
     }
@@ skipping 12 matching lines @@
 
 void KeyLayout::SetTextCallback(
     base::Callback<void(const std::string&)> on_text_callback) {
   on_text_callback_ = on_text_callback;
 }
 
 void KeyLayout::SetDeleteCallback(base::Callback<void()> on_delete_callback) {
   on_delete_callback_ = on_delete_callback;
 }
 
+void KeyLayout::SetSuggestTextCallback(
+    base::Callback<void(const std::string&)> on_suggest_text_callback) {
+  on_suggest_text_callback_ = on_suggest_text_callback;
+}
+
 void KeyLayout::SetKeyArea(const gfx::RectF& key_area) {
   key_area_ = key_area;
 }
 
 void KeyLayout::Draw(SkCanvas* canvas) {
   // Add shadow beneath the key area.
   int blur = 20;
   SkColor color = SkColorSetARGB(0x80, 0, 0, 0);
   std::vector<gfx::ShadowValue> shadows;
   shadows.push_back(gfx::ShadowValue(gfx::Vector2d(0, 0), blur, color));
@@ skipping 17 matching lines @@
   text_paint.setTextAlign(SkPaint::kCenter_Align);
 
   SkPaint paint;
   for (size_t row_index = 0; row_index < layout_->size(); row_index++) {
     float current_top = key_area_.y() + row_index * row_height;
     float current_left = key_area_.x();
     for (size_t key_index = 0; key_index < (*layout_)[row_index].size();
          key_index++) {
       float key_width = static_cast<float>(key_area_.width()) *
                         (*layout_)[row_index][key_index];
-
       (*key_map_)[row_index][key_index]->Draw(
           canvas, text_paint,
           gfx::RectF(current_left, current_top, key_width, row_height));
       current_left += key_width;
     }
   }
 }
 
 KeyLayout::Key* KeyLayout::GetKeyAtPoint(const gfx::PointF& point) {
   if (!key_area_.Contains(point)) {
@@ skipping 13 matching lines @@
   return (*key_map_)[row_index][key_index];
 }
 
 void KeyLayout::OnTouchUp(const gfx::PointF& touch_up) {
   Key* key = GetKeyAtPoint(touch_up);
   if (key != nullptr) {
     key->OnTouchUp();
   }
 }
 
+void KeyLayout::SetPredictor(Predictor* predictor) {
+  predictor_ = predictor;
+  predictor_->SetSuggestionKeys(lower_case_key_map_[0]);
+}
+
 void KeyLayout::InitLayouts() {
   // Row layouts are specified by a vector of floats which indicate the percent
   // width a given key takes up in that row.  The floats of a given row *MUST*
   // add up to 1.
   std::vector<float> ten_key_row_layout = {
       0.1f, 0.1f, 0.1f, 0.1f, 0.1f, 0.1f, 0.1f, 0.1f, 0.1f, 0.1f};
   std::vector<float> nine_key_row_layout = {
       0.15f, 0.1f, 0.1f, 0.1f, 0.1f, 0.1f, 0.1f, 0.1f, 0.15f};
   std::vector<float> seven_key_row_layout = {
       0.15f, 0.1f, 0.1f, 0.3f, 0.1f, 0.1f, 0.15f};
   std::vector<float> five_key_row_layout = {0.15f, 0.1f, 0.5f, 0.1f, 0.15f};
+  std::vector<float> three_key_row_layout = {0.33f, 0.33f, 0.33f};
 
+  letters_layout_.push_back(three_key_row_layout);
   letters_layout_.push_back(ten_key_row_layout);
   letters_layout_.push_back(nine_key_row_layout);
   letters_layout_.push_back(nine_key_row_layout);
   letters_layout_.push_back(five_key_row_layout);
 
+  symbols_layout_.push_back(three_key_row_layout);
   symbols_layout_.push_back(ten_key_row_layout);
   symbols_layout_.push_back(nine_key_row_layout);
   symbols_layout_.push_back(nine_key_row_layout);
   symbols_layout_.push_back(seven_key_row_layout);
 }
 
 void KeyLayout::OnKeyDoNothing(const TextKey& key) {
   // do nothing
 }
 
 void KeyLayout::OnKeyEmitText(const TextKey& key) {
+  predictor_->StoreCurWord(std::string(key.ToText()));
   on_text_callback_.Run(std::string(key.ToText()));
 }
 
 void KeyLayout::OnKeyDelete(const TextKey& key) {
+  predictor_->DeleteCharInCurWord();
   on_delete_callback_.Run();
 }
 
+void KeyLayout::OnSuggestKeyEmitText(const TextUpdateKey& key) {
+  std::string update_string = std::string(key.ToText());
+  int delete_size = predictor_->ChooseSuggestedWord(std::string(key.ToText()));
+  for (int i = 0; i < delete_size; i++) {
+    on_delete_callback_.Run();
+  }
+  on_suggest_text_callback_.Run(update_string);
+}
+
 void KeyLayout::OnKeySwitchToUpperCase(const TextKey& key) {
   layout_ = &letters_layout_;
   key_map_ = &upper_case_key_map_;
+  predictor_->SetSuggestionKeys(upper_case_key_map_[0]);
 }
 
 void KeyLayout::OnKeySwitchToLowerCase(const TextKey& key) {
   layout_ = &letters_layout_;
   key_map_ = &lower_case_key_map_;
+  predictor_->SetSuggestionKeys(lower_case_key_map_[0]);
 }
 
 void KeyLayout::OnKeySwitchToSymbols(const TextKey& key) {
   layout_ = &symbols_layout_;
   key_map_ = &symbols_key_map_;
+  predictor_->SetSuggestionKeys(symbols_key_map_[0]);
 }
 
 void KeyLayout::InitKeyMaps() {
   base::Callback<void(const TextKey&)> do_nothing_callback =
       base::Bind(&KeyLayout::OnKeyDoNothing, weak_factory_.GetWeakPtr());
   base::Callback<void(const TextKey&)> emit_text_callback =
       base::Bind(&KeyLayout::OnKeyEmitText, weak_factory_.GetWeakPtr());
   base::Callback<void(const TextKey&)> delete_callback =
       base::Bind(&KeyLayout::OnKeyDelete, weak_factory_.GetWeakPtr());
+  base::Callback<void(const TextUpdateKey&)> suggest_emit_text_callback =
+      base::Bind(&KeyLayout::OnSuggestKeyEmitText, weak_factory_.GetWeakPtr());
   base::Callback<void(const TextKey&)> switch_to_upper_case_callback =
       base::Bind(&KeyLayout::OnKeySwitchToUpperCase,
                  weak_factory_.GetWeakPtr());
   base::Callback<void(const TextKey&)> switch_to_lower_case_callback =
       base::Bind(&KeyLayout::OnKeySwitchToLowerCase,
                  weak_factory_.GetWeakPtr());
   base::Callback<void(const TextKey&)> switch_to_symbols_callback =
       base::Bind(&KeyLayout::OnKeySwitchToSymbols, weak_factory_.GetWeakPtr());
 
   ImageKey* switch_to_upper_case_image_key = new ImageKey(
       "/\\", switch_to_upper_case_callback, keyboard_native::kUpperCaseIcon);
   ImageKey* switch_to_lower_case_image_key = new ImageKey(
       "\\/", switch_to_lower_case_callback, keyboard_native::kLowerCaseIcon);
   ImageKey* delete_image_key =
       new ImageKey("<-", delete_callback, keyboard_native::kDeleteIcon);
   ImageKey* action_image_key =
       new ImageKey(":)", do_nothing_callback, keyboard_native::kActionIcon);
 
+  std::vector<Key*> suggestion_strip_key_map_row_lower = {
+      new TextUpdateKey("", suggest_emit_text_callback),
+      new TextUpdateKey("", suggest_emit_text_callback),
+      new TextUpdateKey("", suggest_emit_text_callback)};
+
+  std::vector<Key*> suggestion_strip_key_map_row_upper = {
+      new TextUpdateKey("", suggest_emit_text_callback),
+      new TextUpdateKey("", suggest_emit_text_callback),
+      new TextUpdateKey("", suggest_emit_text_callback)};
+
+  std::vector<Key*> suggestion_strip_key_map_row_symbol = {
+      new TextUpdateKey("", suggest_emit_text_callback),
+      new TextUpdateKey("", suggest_emit_text_callback),
+      new TextUpdateKey("", suggest_emit_text_callback)};
+
   std::vector<Key*> lower_case_key_map_row_one = {
       new TextKey("q", emit_text_callback),
       new TextKey("w", emit_text_callback),
       new TextKey("e", emit_text_callback),
       new TextKey("r", emit_text_callback),
       new TextKey("t", emit_text_callback),
       new TextKey("y", emit_text_callback),
       new TextKey("u", emit_text_callback),
       new TextKey("o", emit_text_callback),
       new TextKey("i", emit_text_callback),
@@ skipping 21 matching lines @@
       new TextKey("m", emit_text_callback),
       delete_image_key};
 
   std::vector<Key*> lower_case_key_map_row_four = {
       new TextKey("sym", switch_to_symbols_callback),
       new TextKey(",", emit_text_callback),
       new TextKey(" ", emit_text_callback),
       new TextKey(".", emit_text_callback),
       action_image_key};
 
-  lower_case_key_map_ = {lower_case_key_map_row_one,
+  lower_case_key_map_ = {suggestion_strip_key_map_row_lower,
+                         lower_case_key_map_row_one,
                          lower_case_key_map_row_two,
                          lower_case_key_map_row_three,
                          lower_case_key_map_row_four};
 
   std::vector<Key*> upper_case_key_map_row_one = {
       new TextKey("Q", emit_text_callback),
       new TextKey("W", emit_text_callback),
       new TextKey("E", emit_text_callback),
       new TextKey("R", emit_text_callback),
       new TextKey("T", emit_text_callback),
@@ skipping 25 matching lines @@
       new TextKey("M", emit_text_callback),
       delete_image_key};
 
   std::vector<Key*> upper_case_key_map_row_four = {
       new TextKey("SYM", switch_to_symbols_callback),
       new TextKey(",", emit_text_callback),
       new TextKey(" ", emit_text_callback),
       new TextKey(".", emit_text_callback),
       action_image_key};
 
-  upper_case_key_map_ = {upper_case_key_map_row_one,
+  upper_case_key_map_ = {suggestion_strip_key_map_row_upper,
+                         upper_case_key_map_row_one,
                          upper_case_key_map_row_two,
                          upper_case_key_map_row_three,
                          upper_case_key_map_row_four};
 
   std::vector<Key*> symbols_key_map_row_one = {
       new TextKey("1", emit_text_callback),
       new TextKey("2", emit_text_callback),
       new TextKey("3", emit_text_callback),
       new TextKey("4", emit_text_callback),
       new TextKey("5", emit_text_callback),
@@ skipping 27 matching lines @@
 
   std::vector<Key*> symbols_key_map_row_four = {
       new TextKey("ABC", switch_to_lower_case_callback),
       new TextKey(",", emit_text_callback),
       new TextKey("_", emit_text_callback),
       new TextKey(" ", emit_text_callback),
       new TextKey("/", emit_text_callback),
       new TextKey(".", emit_text_callback),
       action_image_key};
 
-  symbols_key_map_ = {symbols_key_map_row_one,
+  symbols_key_map_ = {suggestion_strip_key_map_row_symbol,
+                      symbols_key_map_row_one,
                       symbols_key_map_row_two,
                       symbols_key_map_row_three,
                       symbols_key_map_row_four};
 }
-}
-// namespace keyboard
+
+}  // namespace keyboard