[TTS] Gather surrounding text on Tap before any UX.

chrome/browser/android/contextualsearch/search_action.cc

+// Copyright 2016 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 "chrome/browser/android/contextualsearch/search_action.h"
+
+#include <set>
+
+#include "base/android/jni_string.h"
+#include "base/bind.h"
+#include "base/memory/weak_ptr.h"
+#include "base/strings/utf_string_conversions.h"
+#include "chrome/browser/android/contextualsearch/contextual_search_context.h"
+#include "content/public/browser/render_frame_host.h"
+#include "content/public/browser/web_contents.h"
+#include "jni/SearchAction_jni.h"
+#include "url/gurl.h"
+
+using base::android::ConvertUTF8ToJavaString;
+using base::android::JavaParamRef;
+using base::android::ScopedJavaGlobalRef;
+using content::WebContents;
+
+namespace {
+const int kSurroundingTextSize = 1536;

[Theresa, 2016/09/01 16:49:37]

nit: where did 1536 come from?

[Donn Denman, 2016/09/02 16:40:43]

Done: added the comment "Context length is set to 1.5K characters for historical
reasons.  This provides the largest context that would fit in a GET request."

However this raises a reasonable question -- why gather so much text?  We are
only using this for Tap suppression, so that larger amount of context may not be
helpful.  We've basically just copied what we do for the resolve, but that might
not be best for suppression.  However, I think it's possible that the amount of
text before or after the selection could be a useful signal, so I think we
should just leave it as-is.

+}
+
+SearchAction::SearchAction(JNIEnv* env, jobject obj) {
+  java_object_.Reset(env, obj);
+}
+
+SearchAction::~SearchAction() {
+  JNIEnv* env = base::android::AttachCurrentThread();
+  Java_SearchAction_clearNativePointer(env, java_object_.obj());
+}
+
+void SearchAction::Destroy(JNIEnv* env, const JavaParamRef<jobject>& obj) {
+  delete this;
+}
+
+void SearchAction::RequestSurroundingText(
+    JNIEnv* env,
+    const JavaParamRef<jobject>& obj,
+    const JavaParamRef<jobject>& j_web_contents) {
+  WebContents* web_contents =
+      WebContents::FromJavaWebContents(j_web_contents.obj());
+  DCHECK(web_contents);
+
+  GURL url(web_contents->GetURL());
+  std::string encoding(web_contents->GetEncoding());
+  search_context_.reset(new ContextualSearchContext(true, url, encoding));
+
+  content::RenderFrameHost* focused_frame = web_contents->GetFocusedFrame();
+  if (!focused_frame) {
+    OnSurroundingTextResponse(base::string16(), 0, 0);
+  } else {
+    focused_frame->RequestTextSurroundingSelection(
+        base::Bind(&SearchAction::OnSurroundingTextResponse, AsWeakPtr()),
+        kSurroundingTextSize);
+  }
+}
+
+void SearchAction::OnSurroundingTextResponse(
+    const base::string16& surrounding_text,
+    int focus_start,
+    int focus_end) {
+  // Record the context, which can be accessed later on demand.
+  search_context_->surrounding_text = surrounding_text;
+  search_context_->start_offset = focus_start;
+  search_context_->end_offset = focus_end;
+
+  // Notify Java.
+  JNIEnv* env = base::android::AttachCurrentThread();
+  Java_SearchAction_onSurroundingTextResponse(env, java_object_.obj());
+}
+
+std::string SearchAction::FindFocusedWord() {
+  DCHECK(search_context_);
+  // Find the focused word.
+  std::pair<int, int> focus = FindFocusedWord(search_context_->surrounding_text,
+                                              search_context_->start_offset,
+                                              search_context_->end_offset);
+  return base::UTF16ToUTF8(search_context_->surrounding_text.substr(
+          focus.first, focus.second - focus.first));
+}
+
+std::string SearchAction::GetSampleText(int sample_length) {
+  DCHECK(search_context_);
+  // Trim surroundings to the requested sample size.
+  std::pair<base::string16, int> sample = SampleSurroundings(
+      search_context_->surrounding_text, search_context_->start_offset,
+      search_context_->end_offset, sample_length);
+  return base::UTF16ToUTF8(sample.first);
+}
+
+// static
+std::pair<int, int> SearchAction::FindFocusedWord(

[pedro (no code reviews), 2016/08/31 22:38:22]

Nit: Why not merge this method with the one with same name above?

[Donn Denman, 2016/09/02 16:40:43]

Done.  It was tricky to figure out how to test non-static methods of this class
since it's linked to a Java class.

Ended up adding a private default constructor for tests, and checking in the
destructor if there's any linked Java object.  Seems like a good approach.

+    const base::string16& surrounding_text,
+    int focus_start,
+    int focus_end) {
+  int surrounding_text_length = surrounding_text.length();
+
+  // First, we need to find the focused word boundaries.
+  int focused_word_start = focus_start;
+  int focused_word_end = focus_end;
+
+  if (surrounding_text_length > 0 &&
+      IsValidCharacter(surrounding_text[focused_word_start])) {
+    // Find focused word start (inclusive)
+    for (int i = focus_start; i >= 0; i--) {
+      focused_word_start = i;
+
+      wchar_t character;
+      if (i > 0) {
+        character = surrounding_text[i - 1];
+
+        if (!IsValidCharacter(character))
+          break;
+      }
+    }
+
+    // Find focused word end (non inclusive)
+    for (int i = focus_end; i < surrounding_text_length; i++) {
+      wchar_t character = surrounding_text[i];
+
+      if (IsValidCharacter(character)) {
+        focused_word_end = i + 1;
+      } else {
+        focused_word_end = i;
+        break;
+      }
+    }
+  }
+
+  return std::pair<int, int>(focused_word_start, focused_word_end);
+}
+
+// static
+std::pair<base::string16, int> SearchAction::SampleSurroundings(
+    const base::string16& surrounding_text,
+    int focus_start,
+    int focus_end,
+    int surrounding_text_sample_limit) {
+  int surrounding_text_length = surrounding_text.length();
+
+  //---------------------------------------------------------------------------
+  // Cut the surrounding size so it can be sent to the Java side.
+
+  // Start equally distributing the size around the focal point.
+  int focal_point_size = focus_end - focus_start;
+  int sample_margin = (surrounding_text_sample_limit - focal_point_size) / 2;
+  int sample_start = focus_start - sample_margin;
+  int sample_end = focus_end + sample_margin;
+
+  // If the the start is out of bounds, compensate the end side.
+  if (sample_start < 0) {
+    sample_end -= sample_start;
+    sample_start = 0;
+  }
+
+  // If the the end is out of bounds, compensate the start side.
+  if (sample_end > surrounding_text_length) {
+    int diff = sample_end - surrounding_text_length;
+    sample_end = surrounding_text_length;
+    sample_start -= diff;
+  }
+
+  // Trim the start and end to make sure they are within bounds.
+  sample_start = std::max(0, sample_start);
+  sample_end = std::min(surrounding_text_length, sample_end);
+  base::string16 sample_string(
+      surrounding_text.substr(sample_start, sample_end - sample_start));
+  std::pair<base::string16, int> sample(sample_string, sample_start);
+  return sample;
+}
+
+// static
+bool SearchAction::IsValidCharacter(int char_code) {
+  // See http://www.unicode.org/Public/UCD/latest/ucd/NamesList.txt
+  // See http://jrgraphix.net/research/unicode_blocks.php
+
+  // TODO(pedrosimonetti): should not include CJK characters!

[pedro (no code reviews), 2016/08/31 22:38:22]

Take over this TODO? This needs to be addressed or it will break resolution on
CJK languages.

[Donn Denman, 2016/09/02 16:40:43]

Done.  

Note: With the current implementation surroundings for the resolution are still
handled by the CS delegate, so resolution should be OK for now.  It will break
the suppression logic however.

+  // TODO(donnd): consider using regular expressions.
+
+  if ((char_code >= 11264 && char_code <= 55295) ||  // Asian language symbols
+      (char_code >= 192 && char_code <= 8191) ||  // Letters in many languages
+      (char_code >= 97 && char_code <= 122) ||    // Lowercase letters
+      (char_code >= 65 && char_code <= 90) ||     // Uppercase letters
+      (char_code >= 48 && char_code <= 57)) {     // Numbers
+    return true;
+  }
+
+  return false;
+}
+
+bool RegisterSearchAction(JNIEnv* env) {
+  return RegisterNativesImpl(env);
+}
+
+jlong Init(JNIEnv* env, const JavaParamRef<jobject>& obj) {
+  SearchAction* content = new SearchAction(env, obj);
+  return reinterpret_cast<intptr_t>(content);
+}