Factor parsing "ln=" to SuggestionAnswer

components/omnibox/browser/suggestion_answer.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/omnibox/browser/suggestion_answer.h"
 
 #include <stddef.h>
 
 #include "base/i18n/rtl.h"
 #include "base/memory/ptr_util.h"
@@ skipping 49 matching lines @@
 }
 
 bool SuggestionAnswer::TextField::Equals(const TextField& field) const {
   return type_ == field.type_ && text_ == field.text_ &&
          has_num_lines_ == field.has_num_lines_ &&
          (!has_num_lines_ || num_lines_ == field.num_lines_);
 }
 
 // SuggestionAnswer::ImageLine -------------------------------------------------
 
-SuggestionAnswer::ImageLine::ImageLine() {}
+SuggestionAnswer::ImageLine::ImageLine()
+    : text_num_lines_(1) {}
 SuggestionAnswer::ImageLine::ImageLine(const ImageLine& line)
     : text_fields_(line.text_fields_),
+      text_num_lines_(line.text_num_lines_),
       additional_text_(line.additional_text_ ?
                        new TextField(*line.additional_text_) : nullptr),
       status_text_(line.status_text_ ?
                    new TextField(*line.status_text_) : nullptr),
       image_url_(line.image_url_) {}
 
 SuggestionAnswer::ImageLine::~ImageLine() {}
 
 // static
 bool SuggestionAnswer::ImageLine::ParseImageLine(
     const base::DictionaryValue* line_json, ImageLine* image_line) {
   const base::DictionaryValue* inner_json;
   if (!line_json->GetDictionary(kAnswerJsonImageLine, &inner_json))
     return false;
 
   const base::ListValue* fields_json;
   if (!inner_json->GetList(kAnswerJsonText, &fields_json) ||
       fields_json->GetSize() == 0)
     return false;
 
+  bool found_num_lines = false;
   for (size_t i = 0; i < fields_json->GetSize(); ++i) {
     const base::DictionaryValue* field_json;
     TextField text_field;
     if (!fields_json->GetDictionary(i, &field_json) ||
         !TextField::ParseTextField(field_json, &text_field))
       return false;
     image_line->text_fields_.push_back(text_field);
+    if (!found_num_lines && text_field.has_num_lines()) {
+      found_num_lines = true;
+      image_line->text_num_lines_ = text_field.num_lines();
+    }
   }
 
   if (inner_json->HasKey(kAnswerJsonAdditionalText)) {
     image_line->additional_text_.reset(new TextField());
     const base::DictionaryValue* field_json;
     if (!inner_json->GetDictionary(kAnswerJsonAdditionalText, &field_json) ||
         !TextField::ParseTextField(field_json,
                                    image_line->additional_text_.get()))
       return false;
   }
@@ skipping 31 matching lines @@
 }
 
 bool SuggestionAnswer::ImageLine::Equals(const ImageLine& line) const {
   if (text_fields_.size() != line.text_fields_.size())
     return false;
   for (size_t i = 0; i < text_fields_.size(); ++i) {
     if (!text_fields_[i].Equals(line.text_fields_[i]))
       return false;
   }
 
+  if (text_num_lines_ != line.text_num_lines_)
+    return false;
+
   if (additional_text_ || line.additional_text_) {
     if (!additional_text_ || !line.additional_text_)
       return false;
     if (!additional_text_->Equals(*line.additional_text_))
       return false;
   }
 
   if (status_text_ || line.status_text_) {
     if (!status_text_ || !line.status_text_)
       return false;
@@ skipping 11 matching lines @@
   for (const TextField& text_field : text_fields_)
     AppendWithSpace(&text_field, &result);
   AppendWithSpace(additional_text_.get(), &result);
   AppendWithSpace(status_text_.get(), &result);
   return result;
 }
 
 // SuggestionAnswer ------------------------------------------------------------
 
 SuggestionAnswer::SuggestionAnswer() : type_(-1) {}
-SuggestionAnswer::SuggestionAnswer(const SuggestionAnswer& answer)
-    : first_line_(answer.first_line_),
-      second_line_(answer.second_line_),
-      type_(answer.type_) {}
 
 SuggestionAnswer::~SuggestionAnswer() {}
 
 // static
 std::unique_ptr<SuggestionAnswer> SuggestionAnswer::ParseAnswer(
     const base::DictionaryValue* answer_json) {
   auto result = base::WrapUnique(new SuggestionAnswer);
 
   const base::ListValue* lines_json;
   if (!answer_json->GetList(kAnswerJsonLines, &lines_json) ||
@@ skipping 18 matching lines @@
          first_line_.Equals(answer.first_line_) &&
          second_line_.Equals(answer.second_line_);
 }
 
 void SuggestionAnswer::AddImageURLsTo(std::vector<GURL>* urls) const {
   if (first_line_.image_url().is_valid())
     urls->push_back(first_line_.image_url());
   if (second_line_.image_url().is_valid())
     urls->push_back(second_line_.image_url());
 }