Convert //chrome/browser/ui from scoped_ptr to std::unique_ptr

chrome/browser/ui/views/omnibox/omnibox_result_view.cc

 // Copyright (c) 2012 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.
 
 // For WinDDK ATL compatibility, these ATL headers must come first.
 #include "build/build_config.h"
 
 #if defined(OS_WIN)
 #include <atlbase.h>  // NOLINT
 #include <atlwin.h>  // NOLINT
@@ skipping 437 matching lines @@
   if (render_text_type == CONTENTS &&
       match.type == AutocompleteMatchType::SEARCH_SUGGEST_TAIL) {
     // When the directionality of suggestion doesn't match the UI, we try to
     // vertically stack the ellipsis by restricting the end edge (right_x).
     const bool is_ui_rtl = base::i18n::IsRTL();
     const bool is_match_contents_rtl =
         (render_text->GetDisplayTextDirection() == base::i18n::RIGHT_TO_LEFT);
     const int offset =
         GetDisplayOffset(match, is_ui_rtl, is_match_contents_rtl);
 
-    scoped_ptr<gfx::RenderText> prefix_render_text(
+    std::unique_ptr<gfx::RenderText> prefix_render_text(
         CreateRenderText(base::UTF8ToUTF16(
             match.GetAdditionalInfo(kACMatchPropertyContentsPrefix))));
     const int prefix_width = prefix_render_text->GetContentWidth();
     int prefix_x = x;
 
     const int max_match_contents_width = model_->max_match_contents_width();
 
     if (is_ui_rtl != is_match_contents_rtl) {
       // RTL infinite suggestions appear near the left edge in LTR UI, while LTR
       // infinite suggestions appear near the right edge in RTL UI. This is
@@ skipping 34 matching lines @@
   // Set the display rect to trigger eliding.
   const int height = (render_text_type == DESCRIPTION && match.answer) ?
       GetAnswerLineHeight() : GetContentLineHeight();
   render_text->SetDisplayRect(
       gfx::Rect(mirroring_context_->mirrored_left_coord(x, right_x), y,
                 right_x - x, height));
   render_text->Draw(canvas);
   return right_x;
 }
 
-scoped_ptr<gfx::RenderText> OmniboxResultView::CreateRenderText(
+std::unique_ptr<gfx::RenderText> OmniboxResultView::CreateRenderText(
     const base::string16& text) const {
-  scoped_ptr<gfx::RenderText> render_text(gfx::RenderText::CreateInstance());
+  std::unique_ptr<gfx::RenderText> render_text(
+      gfx::RenderText::CreateInstance());
   render_text->SetDisplayRect(gfx::Rect(gfx::Size(INT_MAX, 0)));
   render_text->SetCursorEnabled(false);
   render_text->SetElideBehavior(gfx::ELIDE_TAIL);
   render_text->SetFontList(font_list_);
   render_text->SetText(text);
   return render_text;
 }
 
-scoped_ptr<gfx::RenderText> OmniboxResultView::CreateClassifiedRenderText(
+std::unique_ptr<gfx::RenderText> OmniboxResultView::CreateClassifiedRenderText(
     const base::string16& text,
     const ACMatchClassifications& classifications,
     bool force_dim) const {
-  scoped_ptr<gfx::RenderText> render_text(CreateRenderText(text));
+  std::unique_ptr<gfx::RenderText> render_text(CreateRenderText(text));
   const size_t text_length = render_text->text().length();
   for (size_t i = 0; i < classifications.size(); ++i) {
     const size_t text_start = classifications[i].offset;
     if (text_start >= text_length)
       break;
 
     const size_t text_end = (i < (classifications.size() - 1)) ?
         std::min(classifications[i + 1].offset, text_length) :
         text_length;
     const gfx::Range current_range(text_start, text_end);
@@ skipping 45 matching lines @@
     bool is_match_contents_rtl) const {
   if (match.type != AutocompleteMatchType::SEARCH_SUGGEST_TAIL)
     return 0;
 
   const base::string16& input_text =
       base::UTF8ToUTF16(match.GetAdditionalInfo(kACMatchPropertyInputText));
   int contents_start_index = 0;
   base::StringToInt(match.GetAdditionalInfo(kACMatchPropertyContentsStartIndex),
                     &contents_start_index);
 
-  scoped_ptr<gfx::RenderText> input_render_text(CreateRenderText(input_text));
+  std::unique_ptr<gfx::RenderText> input_render_text(
+      CreateRenderText(input_text));
   const gfx::Range& glyph_bounds =
       input_render_text->GetGlyphBounds(contents_start_index);
   const int start_padding = is_match_contents_rtl ?
       std::max(glyph_bounds.start(), glyph_bounds.end()) :
       std::min(glyph_bounds.start(), glyph_bounds.end());
 
   return is_ui_rtl ?
       (input_render_text->GetContentWidth() - start_padding) : start_padding;
 }
 
@@ skipping 183 matching lines @@
       .GetFontList(GetTextStyle(1).font)
       .GetHeight();
 }
 
 int OmniboxResultView::GetContentLineHeight() const {
   return std::max(
       default_icon_size_ + GetLayoutInsets(OMNIBOX_DROPDOWN_ICON).height(),
       GetTextHeight() + GetLayoutInsets(OMNIBOX_DROPDOWN_TEXT).height());
 }
 
-scoped_ptr<gfx::RenderText> OmniboxResultView::CreateAnswerLine(
+std::unique_ptr<gfx::RenderText> OmniboxResultView::CreateAnswerLine(
     const SuggestionAnswer::ImageLine& line,
     gfx::FontList font_list) {
-  scoped_ptr<gfx::RenderText> destination = CreateRenderText(base::string16());
+  std::unique_ptr<gfx::RenderText> destination =
+      CreateRenderText(base::string16());
   destination->SetFontList(font_list);
 
   for (const SuggestionAnswer::TextField& text_field : line.text_fields())
     AppendAnswerText(destination.get(), text_field.text(), text_field.type());
   const base::char16 space(' ');
   const auto* text_field = line.additional_text();
   if (text_field) {
     AppendAnswerText(destination.get(), space + text_field->text(),
                      text_field->type());
   }
@@ skipping 53 matching lines @@
 
 int OmniboxResultView::StartMargin() const {
   return ui::MaterialDesignController::IsModeMaterial() ?
       model_->start_margin() : 0;
 }
 
 int OmniboxResultView::EndMargin() const {
   return ui::MaterialDesignController::IsModeMaterial() ?
       model_->end_margin() : 0;
 }