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

chrome/browser/extensions/api/declarative_content/chrome_content_rules_registry.h

 // 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.
 
 #ifndef CHROME_BROWSER_EXTENSIONS_API_DECLARATIVE_CONTENT_CHROME_CONTENT_RULES_REGISTRY_H_
 #define CHROME_BROWSER_EXTENSIONS_API_DECLARATIVE_CONTENT_CHROME_CONTENT_RULES_REGISTRY_H_
 
 #include <stddef.h>
 
 #include <map>
+#include <memory>
 #include <set>
 #include <string>
 #include <utility>
 #include <vector>
 
 #include "base/callback.h"
 #include "base/macros.h"
 #include "base/memory/linked_ptr.h"
-#include "base/memory/scoped_ptr.h"
 #include "chrome/browser/extensions/api/declarative_content/content_action.h"
 #include "chrome/browser/extensions/api/declarative_content/content_condition.h"
 #include "chrome/browser/extensions/api/declarative_content/content_predicate_evaluator.h"
 #include "content/public/browser/notification_observer.h"
 #include "content/public/browser/notification_registrar.h"
 #include "extensions/browser/api/declarative_content/content_rules_registry.h"
 #include "extensions/common/extension.h"
 
 namespace content {
 class BrowserContext;
@@ skipping 19 matching lines @@
 // however, is only responsible for applying rules registered by the incognito
 // side of split-mode extensions to incognito tabs. The non-incognito instance
 // handles incognito tabs for spanning-mode extensions, plus all non-incognito
 // tabs.
 class ChromeContentRulesRegistry
     : public ContentRulesRegistry,
       public content::NotificationObserver,
       public ContentPredicateEvaluator::Delegate {
  public:
   using PredicateEvaluatorsFactory =
-      base::Callback<std::vector<scoped_ptr<ContentPredicateEvaluator>>(
+      base::Callback<std::vector<std::unique_ptr<ContentPredicateEvaluator>>(
           ContentPredicateEvaluator::Delegate*)>;
 
   // For testing, |cache_delegate| can be NULL. In that case it constructs the
   // registry with storage functionality suspended.
   ChromeContentRulesRegistry(
       content::BrowserContext* browser_context,
       RulesCacheDelegate* cache_delegate,
       const PredicateEvaluatorsFactory& evaluators_factory);
 
   // ContentRulesRegistry:
@@ skipping 28 matching lines @@
 
  protected:
   ~ChromeContentRulesRegistry() override;
 
  private:
   // The internal declarative rule representation. Corresponds to a declarative
   // API rule: https://developer.chrome.com/extensions/events.html#declarative.
   struct ContentRule {
    public:
     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);
     ~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;
 
    private:
     DISALLOW_COPY_AND_ASSIGN(ContentRule);
   };
 
   // Specifies what to do with evaluation requests.
   // TODO(wittman): Try to eliminate the need for IGNORE after refactoring to
   // treat all condition evaluation consistently.
   enum EvaluationDisposition {
     EVALUATE_REQUESTS,  // Evaluate immediately.
     DEFER_REQUESTS,  // Defer for later evaluation.
     IGNORE_REQUESTS  // Ignore.
   };
 
   class EvaluationScope;
 
   // Creates a ContentRule for |extension| given a json definition.  The format
   // of each condition and action's json is up to the specific ContentCondition
   // and ContentAction.  |extension| may be NULL in tests.  If |error| is empty,
   // the translation was successful and the returned rule is internally
   // consistent.
-  scoped_ptr<const ContentRule> CreateRule(
+  std::unique_ptr<const ContentRule> CreateRule(
       const Extension* extension,
       const std::map<std::string, ContentPredicateFactory*>&
           predicate_factories,
       const api::events::Rule& api_rule,
       std::string* error);
 
   // True if this object is managing the rules for |context|.
   bool ManagingRulesForBrowserContext(content::BrowserContext* context);
 
   // True if |condition| matches on |tab|.
@@ skipping 19 matching lines @@
   RulesMap content_rules_;
 
   // Maps a WebContents to the set of rules that match on that WebContents.
   // This lets us call Revert as appropriate. Note that this is expected to have
   // a key-value pair for every WebContents the registry is tracking, even if
   // the value is the empty set.
   std::map<content::WebContents*, std::set<const ContentRule*>> active_rules_;
 
   // The evaluators responsible for creating predicates and tracking
   // predicate-related state.
-  std::vector<scoped_ptr<ContentPredicateEvaluator>> evaluators_;
+  std::vector<std::unique_ptr<ContentPredicateEvaluator>> evaluators_;
 
   // Specifies what to do with evaluation requests.
   EvaluationDisposition evaluation_disposition_;
 
   // Contains WebContents which require rule evaluation. Only used while
   // |evaluation_disposition_| is DEFER.
   std::set<content::WebContents*> evaluation_pending_;
 
   // Manages our notification registrations.
   content::NotificationRegistrar registrar_;
 
   DISALLOW_COPY_AND_ASSIGN(ChromeContentRulesRegistry);
 };
 
 }  // namespace extensions
 
 #endif  // CHROME_BROWSER_EXTENSIONS_API_DECLARATIVE_CONTENT_CHROME_CONTENT_RULES_REGISTRY_H_