Remove ScopedVector from chrome/browser/ui.

chrome/browser/ui/webui/identity_internals_ui.cc

 // Copyright 2013 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/webui/identity_internals_ui.h"
 
 #include <memory>
 #include <set>
 #include <string>
 
 #include "base/bind.h"
 #include "base/i18n/time_formatting.h"
 #include "base/macros.h"
+#include "base/memory/ptr_util.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/values.h"
 #include "chrome/browser/extensions/api/identity/identity_api.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/common/url_constants.h"
 #include "chrome/grit/browser_resources.h"
 #include "chrome/grit/generated_resources.h"
 #include "content/public/browser/web_ui.h"
 #include "content/public/browser/web_ui_controller.h"
 #include "content/public/browser/web_ui_data_source.h"
@@ skipping 64 matching lines @@
   // to the caller using Javascript callback function
   // |identity_internals.returnTokens()|.
   void GetInfoForAllTokens(const base::ListValue* args);
 
   // Initiates revoking of the token, based on the extension ID and token
   // passed as entries in the |args| list. Updates the caller of completion
   // using Javascript callback function |identity_internals.tokenRevokeDone()|.
   void RevokeToken(const base::ListValue* args);
 
   // A vector of token revokers that are currently revoking tokens.
-  ScopedVector<IdentityInternalsTokenRevoker> token_revokers_;
+  std::vector<std::unique_ptr<IdentityInternalsTokenRevoker>> token_revokers_;
 };
 
 // Handles the revoking of an access token and helps performing the clean up
 // after it is revoked by holding information about the access token and related
 // extension ID.
 class IdentityInternalsTokenRevoker : public GaiaAuthConsumer {
  public:
   // Revokes |access_token| from extension with |extension_id|.
   // |profile| is required for its request context. |consumer| will be
   // notified when revocation succeeds via |OnTokenRevokerDone()|.
@@ skipping 43 matching lines @@
   api->EraseCachedToken(token_revoker->extension_id(),
                         token_revoker->access_token());
 
   // Update view about the token being removed.
   base::ListValue result;
   result.AppendString(token_revoker->access_token());
   web_ui()->CallJavascriptFunctionUnsafe("identity_internals.tokenRevokeDone",
                                          result);
 
   // Erase the revoker.
-  ScopedVector<IdentityInternalsTokenRevoker>::iterator iter =
-      std::find(token_revokers_.begin(), token_revokers_.end(), token_revoker);
+  auto iter = token_revokers_.begin();
+  for (; iter != token_revokers_.end(); ++iter) {
+    if (iter->get() == token_revoker)
+      break;
+  }
   DCHECK(iter != token_revokers_.end());
   token_revokers_.erase(iter);

[Bernhard Bauer, 2017/01/04 11:20:09]

Can you move this inside the loop and then make it a regular for (auto it :
token_revokers_) loop? You wouldn't get the DCHECK, but given that that's it's
by definition not required to execute the DCHECK, I'd be okay with leaving it
out (or maybe using a boolean flag |found|)?

[Avi (use Gerrit), 2017/01/04 16:42:34]

I can't switch to an object iterator because I can't then delete, but I can do
something close to that.

 }
 
 const std::string IdentityInternalsUIMessageHandler::GetExtensionName(
     const extensions::ExtensionTokenKey& token_cache_key) {
   const extensions::ExtensionRegistry* registry =
       extensions::ExtensionRegistry::Get(Profile::FromWebUI(web_ui()));
   const extensions::Extension* extension =
       registry->enabled_extensions().GetByID(token_cache_key.extension_id);
   if (!extension)
     return std::string();
@@ skipping 76 matching lines @@
       base::Bind(&IdentityInternalsUIMessageHandler::RevokeToken,
                  base::Unretained(this)));
 }
 
 void IdentityInternalsUIMessageHandler::RevokeToken(
     const base::ListValue* args) {
   std::string extension_id;
   std::string access_token;
   args->GetString(kRevokeTokenExtensionOffset, &extension_id);
   args->GetString(kRevokeTokenTokenOffset, &access_token);
-  token_revokers_.push_back(new IdentityInternalsTokenRevoker(
+  token_revokers_.push_back(base::MakeUnique<IdentityInternalsTokenRevoker>(
       extension_id, access_token, Profile::FromWebUI(web_ui()), this));
 }
 
 IdentityInternalsTokenRevoker::IdentityInternalsTokenRevoker(
     const std::string& extension_id,
     const std::string& access_token,
     Profile* profile,
     IdentityInternalsUIMessageHandler* consumer)
     : fetcher_(this, GaiaConstants::kChromeSource,
                profile->GetRequestContext()),
@@ skipping 43 matching lines @@
   html_source->AddResourcePath("identity_internals.js",
       IDR_IDENTITY_INTERNALS_JS);
   html_source->SetDefaultResource(IDR_IDENTITY_INTERNALS_HTML);
 
   content::WebUIDataSource::Add(Profile::FromWebUI(web_ui), html_source);
 
   web_ui->AddMessageHandler(new IdentityInternalsUIMessageHandler());
 }
 
 IdentityInternalsUI::~IdentityInternalsUI() {}