Code generation for extensions api

chrome/browser/extensions/extension_permissions_api.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/extension_permissions_api.h"
 
 #include "base/memory/scoped_ptr.h"
 #include "base/values.h"
 #include "chrome/browser/extensions/extension_permissions_api_helpers.h"
 #include "chrome/browser/extensions/extension_service.h"
 #include "chrome/browser/extensions/permissions_updater.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/common/chrome_notification_types.h"
+#include "chrome/common/extensions/api/permissions_api.h"
 #include "chrome/common/extensions/extension.h"
 #include "chrome/common/extensions/extension_error_utils.h"
 #include "chrome/common/extensions/url_pattern_set.h"
 #include "googleurl/src/gurl.h"
 
 using extensions::PermissionsUpdater;
+using extensions::permissions_api::Contains;

[Aaron Boodman, 2012/01/19 23:31:13]

Maybe extensions::api::permissions::Contains? Only one character longer, and
cooler!

[calamity, 2012/01/20 01:10:25]

Would we need to change that namespace structure anywhere else?

 using extensions::permissions_api::PackPermissionsToValue;
-using extensions::permissions_api::UnpackPermissionsFromValue;
+using extensions::permissions_api::Remove;
+using extensions::permissions_api::Request;
+using extensions::permissions_api::UnpackPermissionSet;
 
 namespace {
 
 const char kCantRemoveRequiredPermissionsError[] =
     "You cannot remove required permissions.";
 const char kNotInOptionalPermissionsError[] =
     "Optional permissions must be listed in extension manifest.";
 const char kNotWhitelistedError[] =
     "The optional permissions API does not support '*'.";
 const char kUserGestureRequiredError[] =
     "This function must be called during a user gesture";
 
 enum AutoConfirmForTest {
   DO_NOT_SKIP = 0,
   PROCEED,
   ABORT
 };
 AutoConfirmForTest auto_confirm_for_tests = DO_NOT_SKIP;
 bool ignore_user_gesture_for_tests = false;
 
 } // namespace
 
 bool ContainsPermissionsFunction::RunImpl() {
-  DictionaryValue* args = NULL;
-  EXTENSION_FUNCTION_VALIDATE(args_->GetDictionary(0, &args));
-  std::string error;
-  if (!args)
+  Contains::Params params;
+  EXTENSION_FUNCTION_VALIDATE(Contains::Params::Populate(*args_, &params));

[Yoyo Zhou, 2012/01/19 23:19:11]

Should these all be *args_.get()?

[calamity, 2012/01/23 05:14:45]

From what I understand of operator overloading I think the implementations in
base/values.h are equivalent. I'm changing it to *args_ because it's more
concise.

+
+  scoped_refptr<ExtensionPermissionSet> permissions =
+      UnpackPermissionSet(params.permissions, &error_);
+  if (!permissions.get())
     return false;
 
-  scoped_refptr<ExtensionPermissionSet> permissions;
-  if (!UnpackPermissionsFromValue(args, &permissions, &bad_message_, &error_))
-    return false;
-  CHECK(permissions.get());
-
   result_.reset(Value::CreateBooleanValue(
       GetExtension()->GetActivePermissions()->Contains(*permissions)));
   return true;
 }
 
 bool GetAllPermissionsFunction::RunImpl() {
   result_.reset(PackPermissionsToValue(
       GetExtension()->GetActivePermissions()));
   return true;
 }
 
 bool RemovePermissionsFunction::RunImpl() {
-  DictionaryValue* args = NULL;
-  EXTENSION_FUNCTION_VALIDATE(args_->GetDictionary(0, &args));
-  if (!args)
+  Remove::Params params;
+  EXTENSION_FUNCTION_VALIDATE(Remove::Params::Populate(*args_, &params));
+
+  scoped_refptr<ExtensionPermissionSet> permissions =
+      UnpackPermissionSet(params.permissions, &error_);
+  if (!permissions.get())
     return false;
 
-  scoped_refptr<ExtensionPermissionSet> permissions;
-  if (!UnpackPermissionsFromValue(args, &permissions, &bad_message_, &error_))
-    return false;
-  CHECK(permissions.get());
-
   const Extension* extension = GetExtension();
   ExtensionPermissionsInfo* info = ExtensionPermissionsInfo::GetInstance();
 
   // Make sure they're only trying to remove permissions supported by this API.
   ExtensionAPIPermissionSet apis = permissions->apis();
   for (ExtensionAPIPermissionSet::const_iterator i = apis.begin();
        i != apis.end(); ++i) {
     const ExtensionAPIPermission* api = info->GetByID(*i);
     if (!api->supports_optional()) {
       error_ = ExtensionErrorUtils::FormatErrorMessage(
@@ skipping 30 matching lines @@
 
 RequestPermissionsFunction::RequestPermissionsFunction() {}
 RequestPermissionsFunction::~RequestPermissionsFunction() {}
 
 bool RequestPermissionsFunction::RunImpl() {
   if (!user_gesture() && !ignore_user_gesture_for_tests) {
     error_ = kUserGestureRequiredError;
     return false;
   }
 
-  DictionaryValue* args = NULL;
-  EXTENSION_FUNCTION_VALIDATE(args_->GetDictionary(0, &args));
-  if (!args)
+  Request::Params params;
+  EXTENSION_FUNCTION_VALIDATE(Request::Params::Populate(*args_.get(), &params));
+
+  requested_permissions_ = UnpackPermissionSet(params.permissions, &error_);
+  if (!requested_permissions_.get())
     return false;
 
-  if (!UnpackPermissionsFromValue(
-          args, &requested_permissions_, &bad_message_, &error_))
-    return false;
-  CHECK(requested_permissions_.get());
-
   ExtensionPermissionsInfo* info = ExtensionPermissionsInfo::GetInstance();
   ExtensionPrefs* prefs = profile()->GetExtensionService()->extension_prefs();
 
   // Make sure they're only requesting permissions supported by this API.
   ExtensionAPIPermissionSet apis = requested_permissions_->apis();
   for (ExtensionAPIPermissionSet::const_iterator i = apis.begin();
        i != apis.end(); ++i) {
     const ExtensionAPIPermission* api = info->GetByID(*i);
     if (!api->supports_optional()) {
       error_ = ExtensionErrorUtils::FormatErrorMessage(
@@ skipping 56 matching lines @@
 
   Release();  // Balanced in RunImpl().
 }
 
 void RequestPermissionsFunction::InstallUIAbort(bool user_initiated) {
   result_.reset(Value::CreateBooleanValue(false));
   SendResponse(true);
 
   Release();  // Balanced in RunImpl().
 }