[TTS] Add a Java Context linked to existing native

chrome/browser/android/contextualsearch/contextual_search_delegate.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 "chrome/browser/android/contextualsearch/contextual_search_delegate.h"
 
 #include <algorithm>
 #include <utility>
 
 #include "base/base64.h"
@@ skipping 80 matching lines @@
       template_url_service_(template_url_service),
       search_term_callback_(search_term_callback),
       surrounding_callback_(surrounding_callback),
       icing_callback_(icing_callback) {
   field_trial_.reset(new ContextualSearchFieldTrial());
 }
 
 ContextualSearchDelegate::~ContextualSearchDelegate() {
 }
 
-void ContextualSearchDelegate::StartSearchTermResolutionRequest(
-    const std::string& selection,
-    const std::string& home_country,
-    content::WebContents* web_contents,
-    bool may_send_base_page_url) {
-  GatherSurroundingTextWithCallback(
-      selection, home_country, web_contents, may_send_base_page_url,
-      base::Bind(&ContextualSearchDelegate::StartSearchTermRequestFromSelection,
-                 AsWeakPtr()));
+void ContextualSearchDelegate::GatherAndSaveSurroundingText(
+    ContextualSearchContext* contextual_search_context,
+    content::WebContents* web_contents) {
+  DCHECK(web_contents);
+  RenderFrameHost::TextSurroundingSelectionCallback callback =
+      base::Bind(&ContextualSearchDelegate::OnTextSurroundingSelectionAvailable,
+                 AsWeakPtr());
+  context_ = contextual_search_context;
+  context_->SetBasePageEncoding(web_contents->GetEncoding());
+  int surroundingTextSize = context_->CanResolve()
+                                ? field_trial_->GetSurroundingSize()
+                                : field_trial_->GetIcingSurroundingSize();
+  RenderFrameHost* focused_frame = web_contents->GetFocusedFrame();
+  if (focused_frame) {
+    focused_frame->RequestTextSurroundingSelection(callback,
+                                                   surroundingTextSize);
+  } else {
+    callback.Run(base::string16(), 0, 0);
+  }
 }
 
-void ContextualSearchDelegate::GatherAndSaveSurroundingText(
-    const std::string& selection,
-    const std::string& home_country,
-    content::WebContents* web_contents,
-    bool may_send_base_page_url) {
-  GatherSurroundingTextWithCallback(
-      selection, home_country, web_contents, may_send_base_page_url,
-      base::Bind(&ContextualSearchDelegate::SaveSurroundingText, AsWeakPtr()));
-  // TODO(donnd): clear the context here, since we're done with it (but risky).
+void ContextualSearchDelegate::StartSearchTermResolutionRequest(
+    ContextualSearchContext* contextual_search_context,
+    content::WebContents* web_contents) {
+  DCHECK(web_contents);
+  DCHECK(context_ == contextual_search_context);
+  DCHECK(context_->CanResolve());
+
+  // Immediately cancel any request that's in flight, since we're building a new
+  // context (and the response disposes of any existing context).
+  search_term_fetcher_.reset();
+
+  // Decide if the URL should be sent with the context.
+  GURL page_url(web_contents->GetURL());
+  if (context_->CanSendBasePageUrl() &&
+      CanSendPageURL(page_url, ProfileManager::GetActiveUserProfile(),
+                     template_url_service_)) {
+    context_->SetBasePageUrl(page_url);
+  }
+  ResolveSearchTermFromContext();
 }
 
-void ContextualSearchDelegate::ContinueSearchTermResolutionRequest() {
-  DCHECK(context_.get());
-  if (!context_.get())
+void ContextualSearchDelegate::ResolveSearchTermFromContext() {
+  DCHECK(context_);
+  if (!context_)
     return;
-  GURL request_url(BuildRequestUrl(context_->home_country));
+  GURL request_url(BuildRequestUrl(context_->GetHomeCountry()));
   DCHECK(request_url.is_valid());
 
   // Reset will delete any previous fetcher, and we won't get any callback.
   search_term_fetcher_.reset(
       net::URLFetcher::Create(kContextualSearchURLFetcherID, request_url,
                               net::URLFetcher::GET, this).release());
   search_term_fetcher_->SetRequestContext(url_request_context_);
 
   // Add Chrome experiment state to the request headers.
   net::HttpRequestHeaders headers;
@@ skipping 21 matching lines @@
   if (source->GetStatus().is_success() && response_code == net::HTTP_OK) {
     std::string response;
     bool has_string_response = source->GetResponseAsString(&response);
     DCHECK(has_string_response);
     if (has_string_response) {
       resolved_search_term =
           GetResolvedSearchTermFromJson(response_code, response);
     }
   }
   search_term_callback_.Run(*resolved_search_term);
-
-  // The ContextualSearchContext is consumed once the request has completed.
-  context_.reset();
 }
 
 std::unique_ptr<ResolvedSearchTerm>
 ContextualSearchDelegate::GetResolvedSearchTermFromJson(
     int response_code,
     const std::string& json_string) {
   std::string search_term;
   std::string display_text;
   std::string alternate_term;
   std::string mid;
@@ skipping 12 matching lines @@
       json_string, &search_term, &display_text, &alternate_term, &mid,
       &prevent_preload, &mention_start, &mention_end, &context_language,
       &thumbnail_url, &caption, &quick_action_uri, &quick_action_category);
   if (mention_start != 0 || mention_end != 0) {
     // Sanity check that our selection is non-zero and it is less than
     // 100 characters as that would make contextual search bar hide.
     // We also check that there is at least one character overlap between
     // the new and old selection.
     if (mention_start >= mention_end ||
         (mention_end - mention_start) > kContextualSearchMaxSelection ||
-        mention_end <= context_->start_offset ||
-        mention_start >= context_->end_offset) {
+        mention_end <= context_->GetStartOffset() ||
+        mention_start >= context_->GetEndOffset()) {
       start_adjust = 0;
       end_adjust = 0;
     } else {
-      start_adjust = mention_start - context_->start_offset;
-      end_adjust = mention_end - context_->end_offset;
+      start_adjust = mention_start - context_->GetStartOffset();
+      end_adjust = mention_end - context_->GetEndOffset();
     }
   }
   bool is_invalid = response_code == net::URLFetcher::RESPONSE_CODE_INVALID;
   return std::unique_ptr<ResolvedSearchTerm>(new ResolvedSearchTerm(
       is_invalid, response_code, search_term, display_text, alternate_term, mid,
       prevent_preload == kDoPreventPreloadValue, start_adjust, end_adjust,
       context_language, thumbnail_url, caption, quick_action_uri,
       quick_action_category));
 }
 
@@ skipping 42 matching lines @@
   if (!replacement_url.empty()) {
     size_t pos = request.find(kContextualSearchServerEndpoint);
     if (pos != std::string::npos) {
       request.replace(0, pos + strlen(kContextualSearchServerEndpoint),
                       replacement_url);
     }
   }
   return request;
 }
 
-void ContextualSearchDelegate::GatherSurroundingTextWithCallback(
-    const std::string& selection,
-    const std::string& home_country,
-    content::WebContents* web_contents,
-    bool may_send_base_page_url,
-    HandleSurroundingsCallback callback) {
-  // Immediately cancel any request that's in flight, since we're building a new
-  // context (and the response disposes of any existing context).
-  search_term_fetcher_.reset();
-  BuildContext(selection, home_country, web_contents, may_send_base_page_url);
-  DCHECK(web_contents);
-  RenderFrameHost* focused_frame = web_contents->GetFocusedFrame();
-  if (focused_frame) {
-    focused_frame->RequestTextSurroundingSelection(
-        callback, field_trial_->GetSurroundingSize());
-  } else {
-    callback.Run(base::string16(), 0, 0);
-  }
-}
-
-void ContextualSearchDelegate::BuildContext(const std::string& selection,
-                                            const std::string& home_country,
-                                            content::WebContents* web_contents,
-                                            bool may_send_base_page_url) {
-  // Decide if the URL should be sent with the context.
-  GURL page_url(web_contents->GetURL());
-  GURL url_to_send;
-  if (may_send_base_page_url &&
-      CanSendPageURL(page_url, ProfileManager::GetActiveUserProfile(),
-                     template_url_service_)) {
-    url_to_send = page_url;
-  }
-  std::string encoding(web_contents->GetEncoding());
-  context_.reset(new ContextualSearchContext(selection, home_country,
-                                             url_to_send, encoding));
-}
-
-void ContextualSearchDelegate::StartSearchTermRequestFromSelection(
+void ContextualSearchDelegate::OnTextSurroundingSelectionAvailable(
     const base::string16& surrounding_text,
     int start_offset,
     int end_offset) {
-  // TODO(donnd): figure out how to gather text surrounding the selection
-  // for other purposes too: e.g. to determine if we should select the
-  // word where the user tapped.
-  if (context_.get()) {
-    SaveSurroundingText(surrounding_text, start_offset, end_offset);
+  SaveSurroundingText(surrounding_text, start_offset, end_offset);
+  if (context_->CanResolve())
     SendSurroundingText(kSurroundingSizeForUI);
-    ContinueSearchTermResolutionRequest();
-  } else {
-    DVLOG(1) << "ctxs: Null context, ignored!";
-  }
 }
 
 void ContextualSearchDelegate::SaveSurroundingText(
     const base::string16& surrounding_text,
     int start_offset,
     int end_offset) {
-  DCHECK(context_.get());
+  DCHECK(context_);
   // Sometimes the surroundings are 0, 0, '', so fall back on the selection.
   // See crbug.com/393100.
+  bool use_selection = false;
   if (start_offset == 0 && end_offset == 0 && surrounding_text.length() == 0) {
-    context_->surrounding_text = base::UTF8ToUTF16(context_->selected_text);
-    context_->start_offset = 0;
-    context_->end_offset = context_->selected_text.length();
-  } else {
-    context_->surrounding_text = surrounding_text;
-    context_->start_offset = start_offset;
-    context_->end_offset = end_offset;
+    use_selection = true;
+    end_offset = context_->GetOriginalSelectedText().length();
   }
+  const base::string16& surrounding_text_or_selection(
+      use_selection ? base::UTF8ToUTF16(context_->GetOriginalSelectedText())
+                    : surrounding_text);
 
   // Pin the start and end offsets to ensure they point within the string.
-  int surrounding_length = context_->surrounding_text.length();
-  context_->start_offset =
-      std::min(surrounding_length, std::max(0, context_->start_offset));
-  context_->end_offset =
-      std::min(surrounding_length, std::max(0, context_->end_offset));
+  int surrounding_length = surrounding_text_or_selection.length();
+  start_offset = std::min(surrounding_length, std::max(0, start_offset));
+  end_offset = std::min(surrounding_length, std::max(0, end_offset));
+
+  context_->SetSelectionSurroundings(start_offset, end_offset,
+                                     surrounding_text_or_selection);
 
   // Call the Icing callback with a shortened copy of the surroundings.
   int icing_surrounding_size = field_trial_->GetIcingSurroundingSize();
-  size_t selection_start = context_->start_offset;
-  size_t selection_end = context_->end_offset;
-  if (icing_surrounding_size >= 0 && selection_start < selection_end) {
+  size_t selection_start = start_offset;
+  size_t selection_end = end_offset;
+  if (icing_surrounding_size >= 0 && selection_start <= selection_end) {
     int icing_padding_each_side = icing_surrounding_size / 2;
     base::string16 icing_surrounding_text = SurroundingTextForIcing(
-        context_->surrounding_text, icing_padding_each_side, &selection_start,
-        &selection_end);
-    if (selection_start < selection_end)
-      icing_callback_.Run(context_->encoding, icing_surrounding_text,
-                          selection_start, selection_end);
+        surrounding_text_or_selection, icing_padding_each_side,
+        &selection_start, &selection_end);
+    if (selection_start <= selection_end)
+      icing_callback_.Run(context_->GetBasePageEncoding(),
+                          icing_surrounding_text, selection_start,
+                          selection_end);
   }
 }
 
 void ContextualSearchDelegate::SendSurroundingText(int max_surrounding_chars) {
-  const base::string16& surrounding = context_->surrounding_text;
+  const base::string16& surrounding = context_->GetSurroundingText();
 
   // Determine the text after the selection.
   int surrounding_length = surrounding.length();  // Cast to int.
   int num_after_characters = std::min(
-      surrounding_length - context_->end_offset, max_surrounding_chars);
-  base::string16 after_text = surrounding.substr(
-      context_->end_offset, num_after_characters);
+      surrounding_length - context_->GetEndOffset(), max_surrounding_chars);
+  base::string16 after_text =
+      surrounding.substr(context_->GetEndOffset(), num_after_characters);
 
   base::TrimWhitespace(after_text, base::TRIM_ALL, &after_text);
   surrounding_callback_.Run(UTF16ToUTF8(after_text));
 }
 
 void ContextualSearchDelegate::SetDiscourseContextAndAddToHeader(
     const ContextualSearchContext& context) {
   search_term_fetcher_->AddExtraRequestHeader(GetDiscourseContext(context));
 }
 
 std::string ContextualSearchDelegate::GetDiscourseContext(
     const ContextualSearchContext& context) {
   discourse_context::ClientDiscourseContext proto;
   discourse_context::Display* display = proto.add_display();
-  display->set_uri(context.page_url.spec());
+  display->set_uri(context.GetBasePageUrl().spec());
 
   discourse_context::Media* media = display->mutable_media();
-  media->set_mime_type(context.encoding);
+  media->set_mime_type(context.GetBasePageEncoding());
 
   discourse_context::Selection* selection = display->mutable_selection();
-  selection->set_content(UTF16ToUTF8(context.surrounding_text));
-  selection->set_start(context.start_offset);
-  selection->set_end(context.end_offset);
+  selection->set_content(UTF16ToUTF8(context.GetSurroundingText()));
+  selection->set_start(context.GetStartOffset());
+  selection->set_end(context.GetEndOffset());
   selection->set_is_uri_encoded(false);
 
   std::string serialized;
   proto.SerializeToString(&serialized);
 
   std::string encoded_context;
   base::Base64Encode(serialized, &encoded_context);
   // The server memoizer expects a web-safe encoding.
   std::replace(encoded_context.begin(), encoded_context.end(), '+', '-');
   std::replace(encoded_context.begin(), encoded_context.end(), '/', '_');
@@ skipping 192 matching lines @@
     end_offset -= trim;
   }
   if (result_text.length() > end_offset + padding_each_side_pinned) {
     // Trim the end.
     result_text = result_text.substr(0, end_offset + padding_each_side_pinned);
   }
   *start = start_offset;
   *end = end_offset;
   return result_text;
 }