more changes

chrome/browser/extensions/extension_permissions_api.cc

 // Copyright (c) 2011 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/extension_permissions_api.h"
 
 #include "base/json/json_writer.h"
 #include "base/values.h"
 #include "chrome/browser/extensions/extension_event_router.h"
 #include "chrome/browser/extensions/extension_permissions_api_constants.h"
@@ skipping 22 matching lines @@
 AutoConfirmForTest auto_confirm_for_tests = DO_NOT_SKIP;
 
 DictionaryValue* PackPermissionsToValue(const ExtensionPermissionSet* set) {
   DictionaryValue* value = new DictionaryValue();
 
   // Generate the list of API permissions.
   ListValue* apis = new ListValue();
   ExtensionPermissionsInfo* info = ExtensionPermissionsInfo::GetInstance();
   for (ExtensionAPIPermissionSet::const_iterator i = set->apis().begin();
        i != set->apis().end(); ++i)
-    apis->Append(Value::CreateStringValue(info->GetByID(*i)->name()));
+    apis->Append(base::StringValue::New(info->GetByID(*i)->name()));
 
   // Generate the list of origin permissions.
   URLPatternSet hosts = set->explicit_hosts();
   ListValue* origins = new ListValue();
   for (URLPatternSet::const_iterator i = hosts.begin(); i != hosts.end(); ++i)
-    origins->Append(Value::CreateStringValue(i->GetAsString()));
+    origins->Append(base::StringValue::New(i->GetAsString()));
 
   value->Set(keys::kApisKey, apis);
   value->Set(keys::kOriginsKey, origins);
   return value;
 }
 
 // Creates a new ExtensionPermissionSet from its |value| and passes ownership to
 // the caller through |ptr|. Sets |bad_message| to true if the message is badly
 // formed. Returns false if the method fails to unpack a permission set.
 bool UnpackPermissionsFromValue(DictionaryValue* value,
@@ skipping 164 matching lines @@
   EXTENSION_FUNCTION_VALIDATE(args_->GetDictionary(0, &args));
   std::string error;
   if (!args)
     return false;
 
   scoped_refptr<ExtensionPermissionSet> permissions;
   if (!UnpackPermissionsFromValue(args, &permissions, &bad_message_, &error_))
     return false;
   CHECK(permissions.get());
 
-  result_.reset(Value::CreateBooleanValue(
+  result_.reset(base::BooleanValue::New(
       GetExtension()->GetActivePermissions()->Contains(*permissions)));
   return true;
 }
 
 bool GetAllPermissionsFunction::RunImpl() {
   result_.reset(PackPermissionsToValue(
       GetExtension()->GetActivePermissions()));
   return true;
 }
 
@@ skipping 24 matching lines @@
       return false;
     }
   }
 
   // Make sure we don't remove any required pemissions.
   const ExtensionPermissionSet* required = extension->required_permission_set();
   scoped_refptr<ExtensionPermissionSet> intersection(
       ExtensionPermissionSet::CreateIntersection(permissions.get(), required));
   if (!intersection->IsEmpty()) {
     error_ = keys::kCantRemoveRequiredPermissionsError;
-    result_.reset(Value::CreateBooleanValue(false));
+    result_.reset(base::FalseValue());
     return false;
   }
 
   perms_manager->RemovePermissions(extension, permissions.get());
-  result_.reset(Value::CreateBooleanValue(true));
+  result_.reset(base::TrueValue());
   return true;
 }
 
 // static
 void RequestPermissionsFunction::SetAutoConfirmForTests(bool should_proceed) {
   auto_confirm_for_tests = should_proceed ? PROCEED : ABORT;
 }
 
 RequestPermissionsFunction::RequestPermissionsFunction() {}
 RequestPermissionsFunction::~RequestPermissionsFunction() {}
@@ skipping 24 matching lines @@
       error_ = ExtensionErrorUtils::FormatErrorMessage(
           keys::kNotWhitelistedError, api->name());
       return false;
     }
   }
 
   // The requested permissions must be defined as optional in the manifest.
   if (!extension_->optional_permission_set()->Contains(
           *requested_permissions_)) {
     error_ = keys::kNotInOptionalPermissionsError;
-    result_.reset(Value::CreateBooleanValue(false));
+    result_.reset(base::FalseValue());
     return false;
   }
 
   // We don't need to prompt the user if the requested permissions are a subset
   // of the granted permissions set.
   const ExtensionPermissionSet* granted =
       prefs->GetGrantedPermissions(extension_->id());
   if (granted && granted->Contains(*requested_permissions_)) {
     perms_manager->AddPermissions(extension_, requested_permissions_.get());
-    result_.reset(Value::CreateBooleanValue(true));
+    result_.reset(base::TrueValue());
     SendResponse(true);
     return true;
   }
 
   // Filter out the granted permissions so we only prompt for new ones.
   requested_permissions_ = ExtensionPermissionSet::CreateDifference(
       requested_permissions_.get(), granted);
 
   // Balanced with Release() in InstallUIProceed() and InstallUIAbort().
   AddRef();
@@ skipping 15 matching lines @@
   }
 
   return true;
 }
 
 void RequestPermissionsFunction::InstallUIProceed() {
   ExtensionPermissionsManager* perms_manager =
       profile()->GetExtensionService()->permissions_manager();
 
   install_ui_.reset();
-  result_.reset(Value::CreateBooleanValue(true));
+  result_.reset(base::TrueValue());
   perms_manager->AddPermissions(extension_, requested_permissions_.get());
 
   SendResponse(true);
 
   Release();
 }
 
 void RequestPermissionsFunction::InstallUIAbort(bool user_initiated) {
   install_ui_.reset();
-  result_.reset(Value::CreateBooleanValue(false));
+  result_.reset(base::FalseValue());
   requested_permissions_ = NULL;
 
   SendResponse(true);
   Release();
 }