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

extensions/browser/api/declarative/rules_cache_delegate.h

 // 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.
 
 #ifndef EXTENSIONS_BROWSER_API_DECLARATIVE_RULES_CACHE_DELEGATE_H__
 #define EXTENSIONS_BROWSER_API_DECLARATIVE_RULES_CACHE_DELEGATE_H__
 
+#include <memory>
 #include <set>
 #include <string>
 
 #include "base/gtest_prod_util.h"
-#include "base/memory/scoped_ptr.h"
 #include "base/values.h"
 #include "content/public/browser/browser_thread.h"
 
 namespace content {
 class BrowserContext;
 }
 
 namespace extensions {
 
 class RulesRegistry;
@@ skipping 12 matching lines @@
   // Returns a key for the state store. The associated preference is a boolean
   // indicating whether there are some declarative rules stored in the rule
   // store.
   static std::string GetRulesStoredKey(const std::string& event_name,
                                        bool incognito);
 
   // Initialize the storage functionality.
   void Init(RulesRegistry* registry);
 
   void WriteToStorage(const std::string& extension_id,
-                      scoped_ptr<base::Value> value);
+                      std::unique_ptr<base::Value> value);
 
   base::WeakPtr<RulesCacheDelegate> GetWeakPtr() {
     DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
     return weak_ptr_factory_.GetWeakPtr();
   }
 
  private:
   FRIEND_TEST_ALL_PREFIXES(RulesRegistryWithCacheTest,
                            DeclarativeRulesStored);
   FRIEND_TEST_ALL_PREFIXES(RulesRegistryWithCacheTest,
                            RulesStoredFlagMultipleRegistries);
 
   static const char kRulesStoredKey[];
 
   // Check if we are done reading all data from storage on startup, and notify
   // the RulesRegistry on its thread if so. The notification is delivered
   // exactly once.
   void CheckIfReady();
 
   // Schedules retrieving rules for already loaded extensions where
   // appropriate.
   void ReadRulesForInstalledExtensions();
 
   // Read/write a list of rules serialized to Values.
   void ReadFromStorage(const std::string& extension_id);
   void ReadFromStorageCallback(const std::string& extension_id,
-                               scoped_ptr<base::Value> value);
+                               std::unique_ptr<base::Value> value);
 
   // Check the preferences whether the extension with |extension_id| has some
   // rules stored on disk. If this information is not in the preferences, true
   // is returned as a safe default value.
   bool GetDeclarativeRulesStored(const std::string& extension_id) const;
   // Modify the preference to |rules_stored|.
   void SetDeclarativeRulesStored(const std::string& extension_id,
                                  bool rules_stored);
 
   content::BrowserContext* browser_context_;
@@ skipping 21 matching lines @@
   // We notified the RulesRegistry that the rules are loaded.
   bool notified_registry_;
 
   // Use this factory to generate weak pointers bound to the UI thread.
   base::WeakPtrFactory<RulesCacheDelegate> weak_ptr_factory_;
 };
 
 }  // namespace extensions
 
 #endif  // EXTENSIONS_BROWSER_API_DECLARATIVE_RULES_CACHE_DELEGATE_H__