Modify developer_private extensions api to use JSON Schema Compiler

chrome/browser/extensions/api/developer_private/developer_private_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/api/developer_private/developer_private_api.h"
 
 #include "base/base64.h"
 #include "base/file_util.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/utf_string_conversions.h"
@@ skipping 54 matching lines @@
 
   const char kDataURLPrefix[] = "data:image;base64,";
   return GURL(kDataURLPrefix + contents_base64);
 }
 
 
 }  // namespace
 
 namespace extensions {
 
+namespace AllowFileAccess = api::developer_private::AllowFileAccess;
+namespace AllowIncognito = api::developer_private::AllowIncognito;
+namespace ChoosePath = api::developer_private::ChoosePath;
+namespace Enable = api::developer_private::Enable;
+namespace GetItemsInfo = api::developer_private::GetItemsInfo;
+namespace Inspect = api::developer_private::Inspect;
+namespace PackDirectory = api::developer_private::PackDirectory;
+namespace Reload = api::developer_private::Reload;
+namespace Restart = api::developer_private::Restart;
+
 DeveloperPrivateAPI* DeveloperPrivateAPI::Get(Profile* profile) {
   return DeveloperPrivateAPIFactory::GetForProfile(profile);
 }
 
 DeveloperPrivateAPI::DeveloperPrivateAPI(Profile* profile) {
 
       RegisterNotifications();
 }
 
 
@@ skipping 293 matching lines @@
       base::Bind(&DeveloperPrivateGetItemsInfoFunction::GetIconsOnFileThread,
                  this,
                  item_list,
                  id_to_icon));
   return true;
 }
 
 DeveloperPrivateGetItemsInfoFunction::~DeveloperPrivateGetItemsInfoFunction() {}
 
 bool DeveloperPrivateAllowFileAccessFunction::RunImpl() {
-  std::string extension_id;
-  bool allow = false;
+  scoped_ptr<AllowFileAccess::Params> params(
+      AllowFileAccess::Params::Create(*args_));
+  EXTENSION_FUNCTION_VALIDATE(params.get());
+
   EXTENSION_FUNCTION_VALIDATE(user_gesture_);
-  EXTENSION_FUNCTION_VALIDATE(args_->GetString(0, &extension_id));
-  EXTENSION_FUNCTION_VALIDATE(args_->GetBoolean(1, &allow));
 
   ExtensionSystem* system = ExtensionSystem::Get(profile());
   extensions::ManagementPolicy* management_policy =
       system->management_policy();
   ExtensionService* service = profile()->GetExtensionService();
-  const Extension* extension = service->GetInstalledExtension(extension_id);
+  const Extension* extension = service->GetInstalledExtension(params->item_id);
   bool result = true;
 
   if (!extension) {
     result = false;
   } else if (!management_policy->UserMayModifySettings(extension, NULL)) {
     LOG(ERROR) << "Attempt to change allow file access of an extension that "
                << "non-usermanagable was made. Extension id : "
                << extension->id();
     result = false;
   } else {
-    service->SetAllowFileAccess(extension, allow);
+    service->SetAllowFileAccess(extension, params->allow);
     result = true;
   }
 
   return result;
 }
 
 DeveloperPrivateAllowFileAccessFunction::
     ~DeveloperPrivateAllowFileAccessFunction() {}
 
 bool DeveloperPrivateAllowIncognitoFunction::RunImpl() {
-  std::string extension_id;
-  bool allow = false;
-  EXTENSION_FUNCTION_VALIDATE(args_->GetString(0, &extension_id));
-  EXTENSION_FUNCTION_VALIDATE(args_->GetBoolean(1, &allow));
+  scoped_ptr<AllowIncognito::Params> params(
+      AllowIncognito::Params::Create(*args_));
+  EXTENSION_FUNCTION_VALIDATE(params.get());
 
   ExtensionService* service = profile()->GetExtensionService();
-  const Extension* extension = service->GetInstalledExtension(extension_id);
+  const Extension* extension = service->GetInstalledExtension(params->item_id);
   bool result = true;
 
-  if (!extension) {
+  if (!extension)
     result = false;
-  } else {
-    service->SetIsIncognitoEnabled(extension->id(), allow);
-  }
+  else
+    service->SetIsIncognitoEnabled(extension->id(), params->allow);
 
   return result;
 }
 
 DeveloperPrivateAllowIncognitoFunction::
     ~DeveloperPrivateAllowIncognitoFunction() {}
 
 
 bool DeveloperPrivateReloadFunction::RunImpl() {
-  std::string extension_id;
-  EXTENSION_FUNCTION_VALIDATE(args_->GetString(0, &extension_id));
+  scoped_ptr<Reload::Params> params(Reload::Params::Create(*args_));
+  EXTENSION_FUNCTION_VALIDATE(params.get());
+
   ExtensionService* service = profile()->GetExtensionService();
-  CHECK(!extension_id.empty());
-  service->ReloadExtension(extension_id);
+  CHECK(!params->item_id.empty());
+  service->ReloadExtension(params->item_id);
   return true;
 }
 
 DeveloperPrivateReloadFunction::~DeveloperPrivateReloadFunction() {}
 
 bool DeveloperPrivateRestartFunction::RunImpl() {
-  std::string extension_id;
-  EXTENSION_FUNCTION_VALIDATE(args_->GetString(0, &extension_id));
+  scoped_ptr<Restart::Params> params(Restart::Params::Create(*args_));
+  EXTENSION_FUNCTION_VALIDATE(params.get());
+
   ExtensionService* service = profile()->GetExtensionService();
-  EXTENSION_FUNCTION_VALIDATE(!extension_id.empty());
-  service->RestartExtension(extension_id);
+  EXTENSION_FUNCTION_VALIDATE(!params->item_id.empty());
+  service->RestartExtension(params->item_id);
   return true;
 }
 
 DeveloperPrivateRestartFunction::~DeveloperPrivateRestartFunction() {}
 
 DeveloperPrivateEnableFunction::DeveloperPrivateEnableFunction() {}
 
 bool DeveloperPrivateEnableFunction::RunImpl() {
-  std::string extension_id;
-  bool enable = false;
-  EXTENSION_FUNCTION_VALIDATE(args_->GetString(0, &extension_id));
-  EXTENSION_FUNCTION_VALIDATE(args_->GetBoolean(1, &enable));
+  scoped_ptr<Enable::Params> params(Enable::Params::Create(*args_));
+  EXTENSION_FUNCTION_VALIDATE(params.get());
+
+  std::string extension_id = params->item_id;
 
   ExtensionSystem* system = ExtensionSystem::Get(profile());
   extensions::ManagementPolicy* management_policy =
       system->management_policy();
   ExtensionService* service = profile()->GetExtensionService();
 
   const Extension* extension = service->GetInstalledExtension(extension_id);
   if (!extension ||
       !management_policy->UserMayModifySettings(extension, NULL)) {
     LOG(ERROR) << "Attempt to enable an extension that is non-usermanagable "
                "was made. Extension id: " << extension->id();
     return false;
   }
 
-  if (enable) {
+  if (params->enable) {
     extensions::ExtensionPrefs* prefs = service->extension_prefs();
     if (prefs->DidExtensionEscalatePermissions(extension_id)) {
       ShellWindowRegistry* registry = ShellWindowRegistry::Get(profile());
       CHECK(registry);
       ShellWindow* shell_window = registry->GetShellWindowForRenderViewHost(
           render_view_host());
       if (!shell_window) {
         return false;
       }
 
@@ skipping 162 matching lines @@
     response.status = developer::PACK_STATUS_WARNING;
   } else {
     response.status = developer::PACK_STATUS_ERROR;
   }
   results_ = developer::PackDirectory::Results::Create(response);
   SendResponse(true);
   Release();
 }
 
 bool DeveloperPrivatePackDirectoryFunction::RunImpl() {
-  int flags;
-  EXTENSION_FUNCTION_VALIDATE(args_->GetString(0, &item_path_str_));
-  EXTENSION_FUNCTION_VALIDATE(args_->GetString(1, &key_path_str_));
-  EXTENSION_FUNCTION_VALIDATE(args_->GetInteger(2, &flags));
+  scoped_ptr<PackDirectory::Params> params(
+      PackDirectory::Params::Create(*args_));
+  EXTENSION_FUNCTION_VALIDATE(params.get());
 
- base::FilePath root_directory =
+  int flags = params->flags;
+  item_path_str_ = params->path;
+  key_path_str_ = params->private_key_path;
+
+  base::FilePath root_directory =
      base::FilePath::FromWStringHack(UTF8ToWide(item_path_str_));

[cduvall, 2013/03/07 22:43:33]

four space indent from prev line

[Aaron Jacobs, 2013/03/07 22:45:48]

Done.

 
- base::FilePath key_file =
+  base::FilePath key_file =
      base::FilePath::FromWStringHack(UTF8ToWide(key_path_str_));

[cduvall, 2013/03/07 22:43:33]

four space indent from prev line

[Aaron Jacobs, 2013/03/07 22:45:48]

Done.

 
   developer::PackDirectoryResponse response;
   if (root_directory.empty()) {
     if (item_path_str_.empty())
       response.message = l10n_util::GetStringUTF8(
           IDS_EXTENSION_PACK_DIALOG_ERROR_ROOT_REQUIRED);
     else
       response.message = l10n_util::GetStringUTF8(
           IDS_EXTENSION_PACK_DIALOG_ERROR_ROOT_INVALID);
 
@@ skipping 159 matching lines @@
 
   #undef   SET_STRING
   return true;
 }
 
 DeveloperPrivateGetStringsFunction::~DeveloperPrivateGetStringsFunction() {}
 
 } // namespace api
 
 } // namespace extensions