[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;
+  int surroundingTextSize = context_->IsBrief()
+                                ? field_trial_->GetIcingSurroundingSize()
+                                : field_trial_->GetSurroundingSize();
+  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(

[Theresa, 2017/03/08 01:54:38]

nit: It looks like this method and the one above got swapped from their order in
the header file.

[Donn Denman, 2017/03/09 17:35:05]

Fixed -- Changed the order in the header file to be (Gather, Search).

+    ContextualSearchContext* contextual_search_context,
+    content::WebContents* web_contents) {
+  DCHECK(web_contents);
+  DCHECK(context_ == contextual_search_context);
+  DCHECK(!context_->IsBrief());
+
+  // 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());
+  GURL url_to_send;
+  if (context_->MaySendBasePageUrl() &&
+      CanSendPageURL(page_url, ProfileManager::GetActiveUserProfile(),
+                     template_url_service_)) {
+    url_to_send = page_url;
+  }
+  std::string encoding(web_contents->GetEncoding());
+  context_->page_url = url_to_send;
+  context_->encoding = encoding;
+  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));
   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_);
 
@@ skipping 23 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 81 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_->IsBrief())
     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.
   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;
   }
 
   // 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));
 
   // 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) {
+  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)
+    if (selection_start <= selection_end)
       icing_callback_.Run(context_->encoding, icing_surrounding_text,
                           selection_start, selection_end);
   }
 }
 
 void ContextualSearchDelegate::SendSurroundingText(int max_surrounding_chars) {
   const base::string16& surrounding = context_->surrounding_text;
 
   // Determine the text after the selection.
   int surrounding_length = surrounding.length();  // Cast to int.
@@ skipping 229 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;
 }