Revert of Remove ScopedVector in components/spellcheck

components/spellcheck/renderer/spellcheck.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 "components/spellcheck/renderer/spellcheck.h"
 
 #include <stddef.h>
 #include <stdint.h>
 #include <algorithm>
 #include <utility>
@@ skipping 245 matching lines @@
   DocumentMarkersCollector collector;
   content::RenderView::ForEach(&collector);
   content::RenderThread::Get()->Send(
       new SpellCheckHostMsg_RespondDocumentMarkers(collector.markers()));
 }
 
 // TODO(groby): Make sure we always have a spelling engine, even before
 // AddSpellcheckLanguage() is called.
 void SpellCheck::AddSpellcheckLanguage(base::File file,
                                        const std::string& language) {
-  languages_.push_back(base::MakeUnique<SpellcheckLanguage>());
+  languages_.push_back(new SpellcheckLanguage());
   languages_.back()->Init(std::move(file), language);
 }
 
 bool SpellCheck::SpellCheckWord(
     const base::char16* text_begin,
     int position_in_text,
     int text_length,
     int tag,
     int* misspelling_start,
     int* misspelling_len,
@@ skipping 23 matching lines @@
   // skippable.
   for (; position_in_text <= text_length;
        position_in_text += agreed_skippable_len) {
     // Reseting |agreed_skippable_len| to the worst-case length each time
     // prevents some unnecessary iterations.
     agreed_skippable_len = text_length;
     *misspelling_start = 0;
     *misspelling_len = 0;
     suggestions_list.clear();
 
-    for (auto language = languages_.begin(); language != languages_.end();) {
+    for (ScopedVector<SpellcheckLanguage>::iterator language =
+             languages_.begin();
+         language != languages_.end();) {
       language_suggestions.clear();
       SpellcheckLanguage::SpellcheckWordResult result =
           (*language)->SpellCheckWord(
               text_begin, position_in_text, text_length, tag,
               &possible_misspelling_start, &possible_misspelling_len,
               optional_suggestions ? &language_suggestions : nullptr);
 
       switch (result) {
         case SpellcheckLanguage::SpellcheckWordResult::IS_CORRECT:
           *misspelling_start = 0;
@@ skipping 109 matching lines @@
 
   PostDelayedSpellCheckTask(pending_request_param_.release());
 }
 #endif
 
 bool SpellCheck::InitializeIfNeeded() {
   if (languages_.empty())
     return true;
 
   bool initialize_if_needed = false;
-  for (auto& language : languages_)
+  for (SpellcheckLanguage* language : languages_)
     initialize_if_needed |= language->InitializeIfNeeded();
 
   return initialize_if_needed;
 }
 
 // OSX and Android don't have |pending_request_param_|
 #if !BUILDFLAG(USE_BROWSER_SPELLCHECKER)
 void SpellCheck::PostDelayedSpellCheckTask(SpellcheckRequest* request) {
   if (!request)
     return;
 
   base::ThreadTaskRunnerHandle::Get()->PostTask(
       FROM_HERE, base::Bind(&SpellCheck::PerformSpellCheck, AsWeakPtr(),
                             base::Owned(request)));
 }
 #endif
 
 // Mac and Android use their platform engines instead.
 #if !BUILDFLAG(USE_BROWSER_SPELLCHECKER)
 void SpellCheck::PerformSpellCheck(SpellcheckRequest* param) {
   DCHECK(param);
 
   if (languages_.empty() ||
       std::find_if(languages_.begin(), languages_.end(),
-                   [](std::unique_ptr<SpellcheckLanguage>& language) {
+                   [](SpellcheckLanguage* language) {
                      return !language->IsEnabled();
                    }) != languages_.end()) {
     param->completion()->didCancelCheckingText();
   } else {
     WebVector<blink::WebTextCheckingResult> results;
     SpellCheckParagraph(param->text(), &results);
     param->completion()->didFinishCheckingText(results);
   }
 }
 #endif
@@ skipping 55 matching lines @@
 
   textcheck_results->assign(results);
 }
 
 bool SpellCheck::IsSpellcheckEnabled() {
 #if defined(OS_ANDROID)
   if (!spellcheck::IsAndroidSpellCheckFeatureEnabled()) return false;
 #endif
   return spellcheck_enabled_;
 }