[TTS] Decode Now on Tap results for v1 integration.

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 "base/base64.h"
 #include "base/command_line.h"
 #include "base/json/json_string_value_serializer.h"
+#include "base/json/string_escape.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_util.h"
+#include "base/strings/stringprintf.h"
 #include "base/strings/utf_string_conversions.h"
 #include "chrome/browser/android/contextualsearch/contextual_search_field_trial.h"
 #include "chrome/browser/android/contextualsearch/resolved_search_term.h"
 #include "chrome/browser/android/proto/client_discourse_context.pb.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/profiles/profile_manager.h"
 #include "chrome/browser/sync/profile_sync_service_factory.h"
 #include "chrome/browser/translate/translate_service.h"
 #include "chrome/common/pref_names.h"
 #include "components/browser_sync/profile_sync_service.h"
@@ skipping 24 matching lines @@
 const char kContextualSearchServerEndpoint[] = "_/contextualsearch?";
 const int kContextualSearchRequestVersion = 2;
 const int kContextualSearchMaxSelection = 100;
 const char kXssiEscape[] = ")]}'\n";
 const char kDiscourseContextHeaderPrefix[] = "X-Additional-Discourse-Context: ";
 const char kDoPreventPreloadValue[] = "1";
 
 // The number of characters that should be shown after the selected expression.
 const int kSurroundingSizeForUI = 60;
 
+// Contextual Cards (aka Now on Tap) integration.
+const char kContextualSearchContextualCards[] = "contextual_cards";
+const char kContextualSearchCards[] = "cards";
+const char kContextualSearchSingleCard[] = "singleCard";
+const char kContextualSearchSubTitle[] = "subtitle";
+const char kContextualSearchThumbnailUri[] = "thumbnail.uri";
 // The version of the Now on Tap API that we want to invoke.
 const int kNowOnTapVersion = 1;
 
 } // namespace
 
 // URLFetcher ID, only used for tests: we only have one kind of fetcher.
 const int ContextualSearchDelegate::kContextualSearchURLFetcherID = 1;
 
 // Handles tasks for the ContextualSearchManager in a separable, testable way.
 ContextualSearchDelegate::ContextualSearchDelegate(
     net::URLRequestContextGetter* url_request_context,
     TemplateURLService* template_url_service,
     const ContextualSearchDelegate::SearchTermResolutionCallback&
         search_term_callback,
     const ContextualSearchDelegate::SurroundingTextCallback&
         surrounding_callback,
-    const ContextualSearchDelegate::IcingCallback& icing_callback)
+    const ContextualSearchDelegate::IcingCallback& icing_callback,
+    std::unique_ptr<ContextualSearchFieldTrial> field_trial)
     : url_request_context_(url_request_context),
       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());
-}
+      icing_callback_(icing_callback),
+      field_trial_(std::move(field_trial)) {}
 
 ContextualSearchDelegate::~ContextualSearchDelegate() {
 }
 
 void ContextualSearchDelegate::StartSearchTermResolutionRequest(
     const std::string& selection,
     bool use_resolved_search_term,
     content::WebContents* web_contents,
     bool may_send_base_page_url) {
   GatherSurroundingTextWithCallback(
@@ skipping 358 matching lines @@
     std::string* thumbnail_url,
     std::string* caption) {
   bool contains_xssi_escape =
       base::StartsWith(response, kXssiEscape, base::CompareCase::SENSITIVE);
   const std::string& proper_json =
       contains_xssi_escape ? response.substr(sizeof(kXssiEscape) - 1)
                            : response;
   JSONStringValueDeserializer deserializer(proper_json);
   std::unique_ptr<base::Value> root =
       deserializer.Deserialize(nullptr, nullptr);
-  std::unique_ptr<base::DictionaryValue> dict =
+  const std::unique_ptr<base::DictionaryValue> dict =
       base::DictionaryValue::From(std::move(root));
   if (!dict)
     return;
 
   dict->GetString(kContextualSearchPreventPreload, prevent_preload);
   dict->GetString(kContextualSearchResponseSearchTermParam, search_term);
   dict->GetString(kContextualSearchResponseLanguageParam, lang);
 
   // For the display_text, if not present fall back to the "search_term".
   if (!dict->GetString(kContextualSearchResponseDisplayTextParam,
@@ skipping 18 matching lines @@
     *alternate_term = selected_text;
   } else {
     std::string resolved_term;
     dict->GetString(kContextualSearchResponseResolvedTermParam, &resolved_term);
     if (resolved_term != *search_term) {
       *alternate_term = resolved_term;
     }
   }
 
   if (field_trial_->IsNowOnTapBarIntegrationEnabled()) {
-    // TODO(donnd): extract thumbnail_url and caption.
+    DecodeNowOnTapResponse(*dict.get(), caption, thumbnail_url);

[Theresa, 2016/09/20 19:51:39]

nit: I think it makes sense to change "caption" to "subtitle" everywhere up to
the contextual_search_manager.cc call to onSetCaption().

[Donn Denman, 2016/09/20 21:16:36]

Mostly done.

The ContextualSearchContext knows of this as the caption, and I think that's
appropriate, since it's more generic than a subtitle (suitable for translations,
etc).  But I agree that when it comes from Contextual Cards it should be a
subtitle.

   }
 }
 
 // Extract the Start/End of the mentions in the surrounding text
 // for selection-expansion.
 void ContextualSearchDelegate::ExtractMentionsStartEnd(
     const base::ListValue& mentions_list,
     int* startResult,
     int* endResult) {
   int int_value;
@@ skipping 23 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;
 }
+
+void ContextualSearchDelegate::DecodeNowOnTapResponse(
+    const base::DictionaryValue& dict,
+    std::string* subtitle,
+    std::string* thumbnail) {
+  const base::DictionaryValue* contextual_cards_dict = nullptr;
+  if (!dict.GetDictionary(kContextualSearchContextualCards,
+                          &contextual_cards_dict))
+    return;
+
+  DCHECK(contextual_cards_dict);

[Theresa, 2016/09/20 19:51:40]

I don't think this DCHECK is necessary since we return above if
contextual_cards_dict doesn't exist.

[Donn Denman, 2016/09/20 21:16:37]

In that case we should remove all of these DCHECKS.  I'm inclined to leave them
in to help in case of a crash.

Compromise: Added a TODO to remove them all once this code has been exercised,
and removed the one you flagged.

+  const base::ListValue* card_list = nullptr;
+  if (!contextual_cards_dict->GetList(kContextualSearchCards, &card_list))
+    return;
+
+  DCHECK(card_list);
+  for (const auto& card : *card_list) {
+    const base::DictionaryValue* card_dict = nullptr;
+    if (!card->GetAsDictionary(&card_dict))
+      continue;
+
+    DCHECK(card_dict);
+    const base::DictionaryValue* single_card = nullptr;
+    if (!card_dict->GetDictionary(kContextualSearchSingleCard, &single_card))
+      continue;
+
+    DCHECK(single_card);
+    single_card->GetString(kContextualSearchSubTitle, subtitle);
+    single_card->GetString(kContextualSearchThumbnailUri, thumbnail);
+    return;
+  }
+}