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

chrome/browser/extensions/api/declarative_content/chrome_content_rules_registry.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/extensions/api/declarative_content/chrome_content_rules_registry.h"
 
 #include "base/bind.h"
 #include "base/macros.h"
+#include "base/memory/ptr_util.h"
 #include "chrome/browser/chrome_notification_types.h"
 #include "chrome/browser/extensions/api/declarative_content/content_constants.h"
 #include "chrome/browser/extensions/extension_util.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/ui/browser.h"
 #include "chrome/browser/ui/tabs/tab_strip_model.h"
 #include "content/public/browser/navigation_details.h"
 #include "content/public/browser/notification_service.h"
 #include "content/public/browser/notification_source.h"
 #include "content/public/browser/web_contents.h"
@@ skipping 104 matching lines @@
   return ManagingRulesForBrowserContext(context);
 }
 
 void ChromeContentRulesRegistry::MonitorWebContentsForRuleEvaluation(
     content::WebContents* contents) {
   // We rely on active_rules_ to have a key-value pair for |contents| to know
   // which WebContents we are working with.
   active_rules_[contents] = std::set<const ContentRule*>();
 
   EvaluationScope evaluation_scope(this);
-  for (const scoped_ptr<ContentPredicateEvaluator>& evaluator : evaluators_)
+  for (const std::unique_ptr<ContentPredicateEvaluator>& evaluator :
+       evaluators_)
     evaluator->TrackForWebContents(contents);
 }
 
 void ChromeContentRulesRegistry::DidNavigateMainFrame(
     content::WebContents* contents,
     const content::LoadCommittedDetails& details,
     const content::FrameNavigateParams& params) {
   if (ContainsKey(active_rules_, contents)) {
     EvaluationScope evaluation_scope(this);
-    for (const scoped_ptr<ContentPredicateEvaluator>& evaluator : evaluators_)
+    for (const std::unique_ptr<ContentPredicateEvaluator>& evaluator :
+         evaluators_)
       evaluator->OnWebContentsNavigation(contents, details, params);
   }
 }
 
 ChromeContentRulesRegistry::ContentRule::ContentRule(
     const Extension* extension,
-    std::vector<scoped_ptr<const ContentCondition>> conditions,
-    std::vector<scoped_ptr<const ContentAction>> actions,
+    std::vector<std::unique_ptr<const ContentCondition>> conditions,
+    std::vector<std::unique_ptr<const ContentAction>> actions,
     int priority)
     : extension(extension),
       conditions(std::move(conditions)),
       actions(std::move(actions)),
       priority(priority) {}
 
 ChromeContentRulesRegistry::ContentRule::~ContentRule() {}
 
-scoped_ptr<const ChromeContentRulesRegistry::ContentRule>
+std::unique_ptr<const ChromeContentRulesRegistry::ContentRule>
 ChromeContentRulesRegistry::CreateRule(
     const Extension* extension,
     const std::map<std::string, ContentPredicateFactory*>& predicate_factories,
     const api::events::Rule& api_rule,
     std::string* error) {
-  std::vector<scoped_ptr<const ContentCondition>> conditions;
-  for (const scoped_ptr<base::Value>& value : api_rule.conditions) {
+  std::vector<std::unique_ptr<const ContentCondition>> conditions;
+  for (const std::unique_ptr<base::Value>& value : api_rule.conditions) {
     conditions.push_back(
         CreateContentCondition(extension, predicate_factories, *value, error));
     if (!error->empty())
-      return scoped_ptr<ContentRule>();
+      return std::unique_ptr<ContentRule>();
   }
 
-  std::vector<scoped_ptr<const ContentAction>> actions;
-  for (const scoped_ptr<base::Value>& value : api_rule.actions) {
+  std::vector<std::unique_ptr<const ContentAction>> actions;
+  for (const std::unique_ptr<base::Value>& value : api_rule.actions) {
     actions.push_back(ContentAction::Create(browser_context(), extension,
                                             *value, error));
     if (!error->empty())
-      return scoped_ptr<ContentRule>();
+      return std::unique_ptr<ContentRule>();
   }
 
   // Note: |api_rule| may contain tags, but these are ignored.
 
-  return make_scoped_ptr(new ContentRule(extension, std::move(conditions),
-                                         std::move(actions),
-                                         *api_rule.priority));
+  return base::WrapUnique(new ContentRule(extension, std::move(conditions),
+                                          std::move(actions),
+                                          *api_rule.priority));
 }
 
 bool ChromeContentRulesRegistry::ManagingRulesForBrowserContext(
     content::BrowserContext* context) {
   // Manage both the normal context and incognito contexts associated with it.
   return Profile::FromBrowserContext(context)->GetOriginalProfile() ==
       Profile::FromBrowserContext(browser_context());
 }
 
 // static
 bool ChromeContentRulesRegistry::EvaluateConditionForTab(
     const ContentCondition* condition,
     content::WebContents* tab) {
-  for (const scoped_ptr<const ContentPredicate>& predicate :
+  for (const std::unique_ptr<const ContentPredicate>& predicate :
        condition->predicates) {
     if (predicate && !predicate->IsIgnored() &&
         !predicate->GetEvaluator()->EvaluatePredicate(predicate.get(), tab)) {
       return false;
     }
   }
 
   return true;
 }
 
 std::set<const ChromeContentRulesRegistry::ContentRule*>
 ChromeContentRulesRegistry::GetMatchingRules(content::WebContents* tab) const {
   const bool is_incognito_tab = tab->GetBrowserContext()->IsOffTheRecord();
   std::set<const ContentRule*> matching_rules;
   for (const RulesMap::value_type& rule_id_rule_pair : content_rules_) {
     const ContentRule* rule = rule_id_rule_pair.second.get();
     if (is_incognito_tab &&
         !ShouldEvaluateExtensionRulesForIncognitoRenderer(rule->extension))
       continue;
 
-    for (const scoped_ptr<const ContentCondition>& condition :
+    for (const std::unique_ptr<const ContentCondition>& condition :
          rule->conditions) {
       if (EvaluateConditionForTab(condition.get(), tab))
         matching_rules.insert(rule);
     }
   }
   return matching_rules;
 }
 
 std::string ChromeContentRulesRegistry::AddRulesImpl(
     const std::string& extension_id,
     const std::vector<linked_ptr<api::events::Rule>>& api_rules) {
   EvaluationScope evaluation_scope(this);
   const Extension* extension = ExtensionRegistry::Get(browser_context())
       ->GetInstalledExtension(extension_id);
   DCHECK(extension);
 
   std::string error;
   RulesMap new_rules;
   std::map<ContentPredicateEvaluator*,
            std::map<const void*, std::vector<const ContentPredicate*>>>
       new_predicates;
 
   std::map<std::string, ContentPredicateFactory*> predicate_factories;
-  for (const scoped_ptr<ContentPredicateEvaluator>& evaluator : evaluators_) {
+  for (const std::unique_ptr<ContentPredicateEvaluator>& evaluator :
+       evaluators_) {
     predicate_factories[evaluator->GetPredicateApiAttributeName()] =
         evaluator.get();
   }
 
   for (const linked_ptr<api::events::Rule>& api_rule : api_rules) {
     ExtensionIdRuleIdPair rule_id(extension_id, *api_rule->id);
     DCHECK(content_rules_.find(rule_id) == content_rules_.end());
 
-    scoped_ptr<const ContentRule> rule(
+    std::unique_ptr<const ContentRule> rule(
         CreateRule(extension, predicate_factories, *api_rule, &error));
     if (!error.empty()) {
       // Notify evaluators that none of the created predicates will be tracked
       // after all.
-      for (const scoped_ptr<ContentPredicateEvaluator>& evaluator :
+      for (const std::unique_ptr<ContentPredicateEvaluator>& evaluator :
            evaluators_) {
         if (!new_predicates[evaluator.get()].empty()) {
           evaluator->TrackPredicates(
               std::map<const void*, std::vector<const ContentPredicate*>>());
         }
       }
 
       return error;
     }
     DCHECK(rule);
 
     // Group predicates by evaluator and rule, so we can later notify the
     // evaluators that they have new predicates to manage.
-    for (const scoped_ptr<const ContentCondition>& condition :
+    for (const std::unique_ptr<const ContentCondition>& condition :
          rule->conditions) {
-      for (const scoped_ptr<const ContentPredicate>& predicate :
+      for (const std::unique_ptr<const ContentPredicate>& predicate :
            condition->predicates) {
         if (predicate.get()) {
           new_predicates[predicate->GetEvaluator()][rule.get()].push_back(
               predicate.get());
         }
       }
     }
 
     new_rules[rule_id] = make_linked_ptr(rule.release());
   }
 
   // Notify the evaluators about their new predicates.
-  for (const scoped_ptr<ContentPredicateEvaluator>& evaluator : evaluators_)
+  for (const std::unique_ptr<ContentPredicateEvaluator>& evaluator :
+       evaluators_)
     evaluator->TrackPredicates(new_predicates[evaluator.get()]);
 
   // Wohoo, everything worked fine.
   content_rules_.insert(new_rules.begin(), new_rules.end());
 
   // Request evaluation for all WebContents, under the assumption that a
   // non-empty condition has been added.
   for (const auto& web_contents_rules_pair : active_rules_)
     RequestEvaluation(web_contents_rules_pair.first);
 
@@ skipping 29 matching lines @@
           action->Revert(apply_info);
         tab_rules_pair.second.erase(rule);
       }
     }
 
     rules_to_erase.push_back(content_rules_entry);
     predicate_groups_to_stop_tracking.push_back(rule);
   }
 
   // Notify the evaluators to stop tracking the predicates that will be removed.
-  for (const scoped_ptr<ContentPredicateEvaluator>& evaluator : evaluators_)
+  for (const std::unique_ptr<ContentPredicateEvaluator>& evaluator :
+       evaluators_)
     evaluator->StopTrackingPredicates(predicate_groups_to_stop_tracking);
 
   // Remove the rules.
   for (RulesMap::iterator it : rules_to_erase)
     content_rules_.erase(it);
 
   return std::string();
 }
 
 std::string ChromeContentRulesRegistry::RemoveAllRulesImpl(
@@ skipping 13 matching lines @@
     content::WebContents* tab) {
   std::set<const ContentRule*> matching_rules = GetMatchingRules(tab);
   if (matching_rules.empty() && !ContainsKey(active_rules_, tab))
     return;
 
   std::set<const ContentRule*>& prev_matching_rules = active_rules_[tab];
   for (const ContentRule* rule : matching_rules) {
     ContentAction::ApplyInfo apply_info =
         {rule->extension, browser_context(), tab, rule->priority};
     if (!ContainsKey(prev_matching_rules, rule)) {
-      for (const scoped_ptr<const ContentAction>& action : rule->actions)
+      for (const std::unique_ptr<const ContentAction>& action : rule->actions)
         action->Apply(apply_info);
     } else {
-      for (const scoped_ptr<const ContentAction>& action : rule->actions)
+      for (const std::unique_ptr<const ContentAction>& action : rule->actions)
         action->Reapply(apply_info);
     }
   }
   for (const ContentRule* rule : prev_matching_rules) {
     if (!ContainsKey(matching_rules, rule)) {
       ContentAction::ApplyInfo apply_info =
           {rule->extension, browser_context(), tab, rule->priority};
-      for (const scoped_ptr<const ContentAction>& action : rule->actions)
+      for (const std::unique_ptr<const ContentAction>& action : rule->actions)
         action->Revert(apply_info);
     }
   }
 
   if (matching_rules.empty())
     active_rules_[tab].clear();
   else
     swap(matching_rules, prev_matching_rules);
 }
 
@@ skipping 27 matching lines @@
   size_t count = 0;
   for (const auto& web_contents_rules_pair : active_rules_)
     count += web_contents_rules_pair.second.size();
   return count;
 }
 
 ChromeContentRulesRegistry::~ChromeContentRulesRegistry() {
 }
 
 }  // namespace extensions