Remove base::StringValue

components/dom_distiller/core/viewer.cc

 // Copyright 2014 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 "components/dom_distiller/core/viewer.h"
 
 #include <memory>
 #include <string>
 #include <vector>
 
@@ skipping 132 matching lines @@
           IDS_DOM_DISTILLER_VIEWER_CLOSE_READER_VIEW));                   // $8
 
   return base::ReplaceStringPlaceholders(html_template, substitutions, NULL);
 }
 
 }  // namespace
 
 namespace viewer {
 
 const std::string GetShowFeedbackFormJs() {
-  base::StringValue question_val(
+  base::Value question_val(
       l10n_util::GetStringUTF8(IDS_DOM_DISTILLER_QUALITY_QUESTION));
-  base::StringValue no_val(
+  base::Value no_val(
       l10n_util::GetStringUTF8(IDS_DOM_DISTILLER_QUALITY_ANSWER_NO));
-  base::StringValue yes_val(
+  base::Value yes_val(
       l10n_util::GetStringUTF8(IDS_DOM_DISTILLER_QUALITY_ANSWER_YES));
 
   std::string question;
   std::string yes;
   std::string no;
 
   base::JSONWriter::Write(question_val, &question);
   base::JSONWriter::Write(yes_val, &yes);
   base::JSONWriter::Write(no_val, &no);
 
   return "showFeedbackForm(" + question + ", " + yes + ", " + no + ");";
 }
 
 const std::string GetUnsafeIncrementalDistilledPageJs(
     const DistilledPageProto* page_proto,
     const bool is_last_page) {
   std::string output(page_proto->html());
   EnsureNonEmptyContent(&output);
-  base::StringValue value(output);
+  base::Value value(output);
   base::JSONWriter::Write(value, &output);
   std::string page_update("addToPage(");
   page_update += output + ");";
   return page_update + GetToggleLoadingIndicatorJs(
       is_last_page);
 
 }
 
 const std::string GetErrorPageJs() {
   std::string title(l10n_util::GetStringUTF8(
       IDS_DOM_DISTILLER_VIEWER_FAILED_TO_FIND_ARTICLE_TITLE));
   std::string page_update(GetSetTitleJs(title));
 
-  base::StringValue value(l10n_util::GetStringUTF8(
+  base::Value value(l10n_util::GetStringUTF8(
       IDS_DOM_DISTILLER_VIEWER_FAILED_TO_FIND_ARTICLE_CONTENT));
   std::string output;
   base::JSONWriter::Write(value, &output);
   page_update += "addToPage(" + output + ");";
   page_update += GetSetTextDirectionJs(std::string("auto"));
   page_update += GetToggleLoadingIndicatorJs(true);
   if (ShouldShowFeedbackForm()) {
     page_update += GetShowFeedbackFormJs();
   }
   return page_update;
 }
 
 const std::string GetSetTitleJs(std::string title) {
-  base::StringValue value(title);
+  base::Value value(title);
   std::string output;
   base::JSONWriter::Write(value, &output);
   return "setTitle(" + output + ");";
 }
 
 const std::string GetSetTextDirectionJs(const std::string& direction) {
-  base::StringValue value(direction);
+  base::Value value(direction);
   std::string output;
   base::JSONWriter::Write(value, &output);
   return "setTextDirection(" + output + ");";
 }
 
 const std::string GetToggleLoadingIndicatorJs(const bool is_last_page) {
   if (is_last_page)
     return "showLoadingIndicator(true);";
   else
     return "showLoadingIndicator(false);";
@@ skipping 11 matching lines @@
   DCHECK(article_proto);
   std::ostringstream unsafe_output_stream;
   if (article_proto->pages_size() > 0 && article_proto->pages(0).has_html()) {
     for (int page_num = 0; page_num < article_proto->pages_size(); ++page_num) {
       unsafe_output_stream << article_proto->pages(page_num).html();
     }
   }
 
   std::string output(unsafe_output_stream.str());
   EnsureNonEmptyContent(&output);
-  base::JSONWriter::Write(base::StringValue(output), &output);
+  base::JSONWriter::Write(base::Value(output), &output);
   std::string page_update("addToPage(");
   page_update += output + ");";
   return page_update + GetToggleLoadingIndicatorJs(true);
 }
 
 const std::string GetCss() {
   return ResourceBundle::GetSharedInstance().GetRawDataResource(
           IDR_DISTILLER_CSS).as_string();
 }
 
@@ skipping 59 matching lines @@
   return "useFontFamily('" + GetJsFontFamily(font_family) + "');";
 }
 
 const std::string GetDistilledPageFontScalingJs(float scaling) {
   return "useFontScaling(" + base::DoubleToString(scaling) + ");";
 }
 
 }  // namespace viewer
 
 }  // namespace dom_distiller