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

chrome/browser/ui/search_engines/template_url_table_model.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.
 
 #include "chrome/browser/ui/search_engines/template_url_table_model.h"
 
 #include <utility>
 
 #include "base/bind.h"
 #include "base/i18n/rtl.h"
@@ skipping 229 matching lines @@
     return kMainGroupID;
   return row < last_other_engine_index_ ? kOtherGroupID : kExtensionGroupID;
 }
 
 void TemplateURLTableModel::Remove(int index) {
   // Remove the observer while we modify the model, that way we don't need to
   // worry about the model calling us back when we mutate it.
   template_url_service_->RemoveObserver(this);
   TemplateURL* template_url = GetTemplateURL(index);
 
-  scoped_ptr<ModelEntry> entry(RemoveEntry(index));
+  std::unique_ptr<ModelEntry> entry(RemoveEntry(index));
 
   // Make sure to remove from the table model first, otherwise the
   // TemplateURL would be freed.
   template_url_service_->Remove(template_url);
   template_url_service_->AddObserver(this);
 }
 
 void TemplateURLTableModel::Add(int index,
                                 const base::string16& short_name,
                                 const base::string16& keyword,
                                 const std::string& url) {
   DCHECK(index >= 0 && index <= RowCount());
   DCHECK(!url.empty());
   template_url_service_->RemoveObserver(this);
   TemplateURLData data;
   data.SetShortName(short_name);
   data.SetKeyword(keyword);
   data.SetURL(url);
   TemplateURL* turl = new TemplateURL(data);
   template_url_service_->Add(turl);
-  scoped_ptr<ModelEntry> entry(new ModelEntry(this, turl));
+  std::unique_ptr<ModelEntry> entry(new ModelEntry(this, turl));
   template_url_service_->AddObserver(this);
   AddEntry(index, std::move(entry));
 }
 
 void TemplateURLTableModel::ModifyTemplateURL(int index,
                                               const base::string16& title,
                                               const base::string16& keyword,
                                               const std::string& url) {
   DCHECK(index >= 0 && index <= RowCount());
   DCHECK(!url.empty());
@@ skipping 28 matching lines @@
     if (entry->template_url() == template_url)
       return static_cast<int>(i - entries_.begin());
   }
   return -1;
 }
 
 int TemplateURLTableModel::MoveToMainGroup(int index) {
   if (index < last_search_engine_index_)
     return index;  // Already in the main group.
 
-  scoped_ptr<ModelEntry> current_entry(RemoveEntry(index));
+  std::unique_ptr<ModelEntry> current_entry(RemoveEntry(index));
   const int new_index = last_search_engine_index_++;
   AddEntry(new_index, std::move(current_entry));
   return new_index;
 }
 
 int TemplateURLTableModel::MakeDefaultTemplateURL(int index) {
   if (index < 0 || index >= RowCount()) {
     NOTREACHED();
     return -1;
   }
@@ skipping 35 matching lines @@
   std::vector<ModelEntry*>::iterator i =
       std::find(entries_.begin(), entries_.end(), entry);
   DCHECK(i != entries_.end());
   NotifyChanged(static_cast<int>(i - entries_.begin()));
 }
 
 void TemplateURLTableModel::OnTemplateURLServiceChanged() {
   Reload();
 }
 
-scoped_ptr<TemplateURLTableModel::ModelEntry>
+std::unique_ptr<TemplateURLTableModel::ModelEntry>
 TemplateURLTableModel::RemoveEntry(int index) {
-  scoped_ptr<ModelEntry> entry(entries_[index]);
+  std::unique_ptr<ModelEntry> entry(entries_[index]);
   entries_.erase(index + entries_.begin());
   if (index < last_search_engine_index_)
     --last_search_engine_index_;
   if (index < last_other_engine_index_)
     --last_other_engine_index_;
   if (observer_)
     observer_->OnItemsRemoved(index, 1);
   return entry;
 }
 
-void TemplateURLTableModel::AddEntry(int index, scoped_ptr<ModelEntry> entry) {
+void TemplateURLTableModel::AddEntry(int index,
+                                     std::unique_ptr<ModelEntry> entry) {
   entries_.insert(entries_.begin() + index, entry.release());
   if (index <= last_other_engine_index_)
     ++last_other_engine_index_;
   if (observer_)
     observer_->OnItemsAdded(index, 1);
 }