--- core/includes/form.inc	2013-10-18 15:59:24.000000000 -0700
+++ /Users/timplunk/www/d8/core/lib/Drupal/Core/Form/FormBuilder.php	2013-10-18 15:57:45.000000000 -0700
@@ -2,40 +2,38 @@
 
 /**
  * @file
- * Functions for form and batch generation and processing.
+ * Contains \Drupal\Core\Form\FormBuilder.
  */
 
+namespace Drupal\Core\Form;
+
 use Drupal\Component\Utility\Crypt;
 use Drupal\Component\Utility\NestedArray;
-use Drupal\Component\Utility\Number;
-use Drupal\Component\Utility\String;
+use Drupal\Component\Utility\Unicode;
 use Drupal\Component\Utility\Url;
-use Drupal\Core\Form\FormInterface;
-use Drupal\Core\Form\BaseFormIdInterface;
-use Drupal\Core\Database\Database;
-use Drupal\Core\Language\Language;
-use Drupal\Core\Template\Attribute;
-use Drupal\Core\Datetime\DrupalDateTime;
-use Drupal\Core\Utility\Color;
-use Symfony\Component\HttpFoundation\Response;
+use Drupal\Core\Access\CsrfTokenGenerator;
+use Drupal\Core\Extension\ModuleHandlerInterface;
+use Drupal\Core\HttpKernel;
+use Drupal\Core\KeyValueStore\KeyValueExpirableFactory;
+use Drupal\Core\Routing\UrlGeneratorInterface;
+use Drupal\Core\StringTranslation\TranslationInterface;
+use Symfony\Component\EventDispatcher\EventDispatcherInterface;
 use Symfony\Component\HttpFoundation\RedirectResponse;
-use Symfony\Component\HttpKernel\KernelEvents;
+use Symfony\Component\HttpFoundation\Request;
+use Symfony\Component\HttpFoundation\Response;
 use Symfony\Component\HttpKernel\Event\FilterResponseEvent;
+use Symfony\Component\HttpKernel\HttpKernelInterface;
+use Symfony\Component\HttpKernel\KernelEvents;
 
 /**
- * Determines the form ID.
- *
- * @param \Drupal\Core\Form\FormInterface|string $form_arg
- *   A form object to use to build the form, or the unique string identifying
- *   the desired form. If $form_arg is a string and a function with that
- *   name exists, it is called to build the form array.
- * @param array $form_state
- *   An associative array containing the current state of the form.
- *
- * @return string
- *   The unique string identifying the desired form.
+ * Provides form building and processing.
  */
-function _drupal_form_id($form_arg, &$form_state) {
+class FormBuilder implements FormBuilderInterface {
+
+  /**
+   * {@inheritdoc}
+   */
+  public function getFormId($form_arg, &$form_state) {
   // If the $form_arg is the name of a class, instantiate it.
   if (is_string($form_arg) && class_exists($form_arg)) {
     if (in_array('Drupal\Core\DependencyInjection\ContainerInjectionInterface', class_implements($form_arg))) {
@@ -45,7 +43,6 @@ function _drupal_form_id($form_arg, &$fo
       $form_arg = new $form_arg();
     }
   }
-
   // If the $form_arg implements \Drupal\Core\Form\FormInterface, add that as
   // the callback object and determine the form ID.
   if (is_object($form_arg) && $form_arg instanceof FormInterface) {
@@ -61,34 +58,9 @@ function _drupal_form_id($form_arg, &$fo
 }
 
 /**
- * Returns a renderable form array for a given form ID.
- *
- * This function should be used instead of drupal_build_form() when $form_state
- * is not needed (i.e., when initially rendering the form) and is often
- * used as a menu callback.
- *
- * @param \Drupal\Core\Form\FormInterface|string $form_arg
- *   A form object to use to build the form, or the unique string identifying
- *   the desired form. If $form_arg is a string and a function with that
- *   name exists, it is called to build the form array. Modules that need to
- *   generate the same form (or very similar forms) using different $form_ids
- *   can implement hook_forms(), which maps different $form_id values to the
- *   proper form constructor function. Examples may be found in node_forms(),
- *   and search_forms().
- * @param ...
- *   Any additional arguments are passed on to the functions called by
- *   drupal_get_form(), including the unique form constructor function. For
- *   example, the node_edit form requires that a node object is passed in here
- *   when it is called. These are available to implementations of
- *   hook_form_alter() and hook_form_FORM_ID_alter() as the array
- *   $form_state['build_info']['args'].
- *
- * @return
- *   The form array.
- *
- * @see drupal_build_form()
+   * {@inheritdoc}
  */
-function drupal_get_form($form_arg) {
+  public function getForm($form_arg) {
   $form_state = array();
 
   $args = func_get_args();
@@ -96,182 +68,16 @@ function drupal_get_form($form_arg) {
   array_shift($args);
   $form_state['build_info']['args'] = $args;
 
-  $form_id = _drupal_form_id($form_arg, $form_state);
-  return drupal_build_form($form_id, $form_state);
+    $form_id = $this->getFormId($form_arg, $form_state);
+    return $this->buildForm($form_id, $form_state);
 }
 
 /**
- * Builds and processes a form for a given form ID.
- *
- * The form may also be retrieved from the cache if the form was built in a
- * previous page-load. The form is then passed on for processing, validation
- * and submission if there is proper input.
- *
- * @param $form_id
- *   The unique string identifying the desired form. If a function with that
- *   name exists, it is called to build the form array. Modules that need to
- *   generate the same form (or very similar forms) using different $form_ids
- *   can implement hook_forms(), which maps different $form_id values to the
- *   proper form constructor function. Examples may be found in node_forms(),
- *   and search_forms().
- * @param $form_state
- *   An array which stores information about the form. This is passed as a
- *   reference so that the caller can use it to examine what in the form changed
- *   when the form submission process is complete. Furthermore, it may be used
- *   to store information related to the processed data in the form, which will
- *   persist across page requests when the 'cache' or 'rebuild' flag is set.
- *   The following parameters may be set in $form_state to affect how the form
- *   is rendered:
- *   - build_info: Internal. An associative array of information stored by Form
- *     API that is necessary to build and rebuild the form from cache when the
- *     original context may no longer be available:
- *     - callback: The actual callback to be used to retrieve the form array. If
- *       none is provided $form_id is used instead. Can be any callable type.
- *     - args: A list of arguments to pass to the form constructor.
- *     - files: An optional array defining include files that need to be loaded
- *       for building the form. Each array entry may be the path to a file or
- *       another array containing values for the parameters 'type', 'module' and
- *       'name' as needed by module_load_include(). The files listed here are
- *       automatically loaded by form_get_cache(). By default the current menu
- *       router item's 'file' definition is added, if any. Use
- *       form_load_include() to add include files from a form constructor.
- *     - form_id: Identification of the primary form being constructed and
- *       processed.
- *     - base_form_id: Identification for a base form, as declared in a
- *       hook_forms() implementation.
- *   - rebuild_info: Internal. Similar to 'build_info', but pertaining to
- *     drupal_rebuild_form().
- *   - rebuild: Normally, after the entire form processing is completed and
- *     submit handlers have run, a form is considered to be done and
- *     drupal_redirect_form() will redirect the user to a new page using a GET
- *     request (so a browser refresh does not re-submit the form). However, if
- *     'rebuild' has been set to TRUE, then a new copy of the form is
- *     immediately built and sent to the browser, instead of a redirect. This is
- *     used for multi-step forms, such as wizards and confirmation forms.
- *     Normally, $form_state['rebuild'] is set by a submit handler, since it is
- *     usually logic within a submit handler that determines whether a form is
- *     done or requires another step. However, a validation handler may already
- *     set $form_state['rebuild'] to cause the form processing to bypass submit
- *     handlers and rebuild the form instead, even if there are no validation
- *     errors.
- *   - redirect: Used to redirect the form on submission. It may either be a
- *     string containing the destination URL, or an array of arguments
- *     compatible with url(). See url() for complete information.
- *   - no_redirect: If set to TRUE the form will NOT perform a redirect,
- *     even if 'redirect' is set.
- *   - method: The HTTP form method to use for finding the input for this form.
- *     May be 'post' or 'get'. Defaults to 'post'. Note that 'get' method
- *     forms do not use form ids so are always considered to be submitted, which
- *     can have unexpected effects. The 'get' method should only be used on
- *     forms that do not change data, as that is exclusively the domain of
- *     'post.'
- *   - cache: If set to TRUE the original, unprocessed form structure will be
- *     cached, which allows the entire form to be rebuilt from cache. A typical
- *     form workflow involves two page requests; first, a form is built and
- *     rendered for the user to fill in. Then, the user fills the form in and
- *     submits it, triggering a second page request in which the form must be
- *     built and processed. By default, $form and $form_state are built from
- *     scratch during each of these page requests. Often, it is necessary or
- *     desired to persist the $form and $form_state variables from the initial
- *     page request to the one that processes the submission. 'cache' can be set
- *     to TRUE to do this. A prominent example is an Ajax-enabled form, in which
- *     ajax_process_form() enables form caching for all forms that include an
- *     element with the #ajax property. (The Ajax handler has no way to build
- *     the form itself, so must rely on the cached version.) Note that the
- *     persistence of $form and $form_state happens automatically for
- *     (multi-step) forms having the 'rebuild' flag set, regardless of the value
- *     for 'cache'.
- *   - no_cache: If set to TRUE the form will NOT be cached, even if 'cache' is
- *     set.
- *   - values: An associative array of values submitted to the form. The
- *     validation functions and submit functions use this array for nearly all
- *     their decision making. (Note that #tree determines whether the values
- *     are a flat array or an array whose structure parallels the $form array.
- *     See the @link forms_api_reference.html Form API reference @endlink for
- *     more information.)
- *   - input: The array of values as they were submitted by the user. These are
- *     raw and unvalidated, so should not be used without a thorough
- *     understanding of security implications. In almost all cases, code should
- *     use the data in the 'values' array exclusively. The most common use of
- *     this key is for multi-step forms that need to clear some of the user
- *     input when setting 'rebuild'. The values correspond to $_POST or $_GET,
- *     depending on the 'method' chosen.
- *   - always_process: If TRUE and the method is GET, a form_id is not
- *     necessary. This should only be used on RESTful GET forms that do NOT
- *     write data, as this could lead to security issues. It is useful so that
- *     searches do not need to have a form_id in their query arguments to
- *     trigger the search.
- *   - must_validate: Ordinarily, a form is only validated once, but there are
- *     times when a form is resubmitted internally and should be validated
- *     again. Setting this to TRUE will force that to happen. This is most
- *     likely to occur during Ajax operations.
- *   - programmed: If TRUE, the form was submitted programmatically, usually
- *     invoked via drupal_form_submit(). Defaults to FALSE.
- *   - process_input: Boolean flag. TRUE signifies correct form submission.
- *     This is always TRUE for programmed forms coming from drupal_form_submit()
- *     (see 'programmed' key), or if the form_id coming from the $_POST data is
- *     set and matches the current form_id.
- *   - submitted: If TRUE, the form has been submitted. Defaults to FALSE.
- *   - executed: If TRUE, the form was submitted and has been processed and
- *     executed. Defaults to FALSE.
- *   - triggering_element: (read-only) The form element that triggered
- *     submission, which may or may not be a button (in the case of Ajax forms).
- *     This key is often used to distinguish between various buttons in a submit
- *     handler, and is also used in Ajax handlers.
- *   - has_file_element: Internal. If TRUE, there is a file element and Form API
- *     will set the appropriate 'enctype' HTML attribute on the form.
- *   - groups: Internal. An array containing references to details elements to
- *     render them within vertical tabs.
- *   - storage: $form_state['storage'] is not a special key, and no specific
- *     support is provided for it in the Form API. By tradition it was
- *     the location where application-specific data was stored for communication
- *     between the submit, validation, and form builder functions, especially
- *     in a multi-step-style form. Form implementations may use any key(s)
- *     within $form_state (other than the keys listed here and other reserved
- *     ones used by Form API internals) for this kind of storage. The
- *     recommended way to ensure that the chosen key doesn't conflict with ones
- *     used by the Form API or other modules is to use the module name as the
- *     key name or a prefix for the key name. For example, the entity form
- *     controller classes use $this->entity in entity forms, or
- *     $form_state['controller']->getEntity() outside the controller, to store
- *     information about the entity being edited, and this information stays
- *     available across successive clicks of the "Preview" button (if available)
- *     as well as when the "Save" button is finally clicked.
- *   - buttons: A list containing copies of all submit and button elements in
- *     the form.
- *   - complete_form: A reference to the $form variable containing the complete
- *     form structure. #process, #after_build, #element_validate, and other
- *     handlers being invoked on a form element may use this reference to access
- *     other information in the form the element is contained in.
- *   - temporary: An array holding temporary data accessible during the current
- *     page request only. All $form_state properties that are not reserved keys
- *     (see form_state_keys_no_cache()) persist throughout a multistep form
- *     sequence. Form API provides this key for modules to communicate
- *     information across form-related functions during a single page request.
- *     It may be used to temporarily save data that does not need to or should
- *     not be cached during the whole form workflow; e.g., data that needs to be
- *     accessed during the current form build process only. There is no use-case
- *     for this functionality in Drupal core.
- *   - wrapper_callback: Modules that wish to pre-populate certain forms with
- *     common elements, such as back/next/save buttons in multi-step form
- *     wizards, may define a form builder function name that returns a form
- *     structure, which is passed on to the actual form builder function.
- *     Such implementations may either define the 'wrapper_callback' via
- *     hook_forms() or have to invoke drupal_build_form() (instead of
- *     drupal_get_form()) on their own in a custom menu callback to prepare
- *     $form_state accordingly.
- *   Information on how certain $form_state properties control redirection
- *   behavior after form submission may be found in drupal_redirect_form().
- *
- * @return
- *   The rendered form. This function may also perform a redirect and hence may
- *   not return at all, depending upon the $form_state flags that were set.
- *
- * @see drupal_redirect_form()
+   * {@inheritdoc}
  */
-function drupal_build_form($form_id, &$form_state) {
+  public function buildForm($form_id, &$form_state) {
   // Ensure some defaults; if already set they will not be overridden.
-  $form_state += form_state_defaults();
+    $form_state += $this->getFormStateDefaults();
 
   if (!isset($form_state['input'])) {
     $form_state['input'] = $form_state['method'] == 'get' ? $_GET : $_POST;
@@ -282,7 +88,7 @@ function drupal_build_form($form_id, &$f
     // already been processed, but needs to be rebuilt. See _batch_finished().
     $form_state = $_SESSION['batch_form_state'];
     unset($_SESSION['batch_form_state']);
-    return drupal_rebuild_form($form_id, $form_state);
+      return $this->rebuildForm($form_id, $form_state);
   }
 
   // If the incoming input contains a form_build_id, we'll check the cache for a
@@ -292,7 +98,7 @@ function drupal_build_form($form_id, &$f
   // processing code.
   $check_cache = isset($form_state['input']['form_id']) && $form_state['input']['form_id'] == $form_id && !empty($form_state['input']['form_build_id']);
   if ($check_cache) {
-    $form = form_get_cache($form_state['input']['form_build_id'], $form_state);
+      $form = $this->getCache($form_state['input']['form_build_id'], $form_state);
   }
 
   // If the previous bit of code didn't result in a populated $form object, we
@@ -306,17 +112,17 @@ function drupal_build_form($form_id, &$f
       $form_state_before_retrieval = $form_state;
     }
 
-    $form = drupal_retrieve_form($form_id, $form_state);
-    drupal_prepare_form($form_id, $form, $form_state);
+      $form = $this->retrieveForm($form_id, $form_state);
+      $this->prepareForm($form_id, $form, $form_state);
 
-    // form_set_cache() removes uncacheable $form_state keys defined in
-    // form_state_keys_no_cache() in order for multi-step forms to work
+      // self::setCache() removes uncacheable $form_state keys defined in
+      // self::getUncacheableKeys() in order for multi-step forms to work
     // properly. This means that form processing logic for single-step forms
     // using $form_state['cache'] may depend on data stored in those keys
-    // during drupal_retrieve_form()/drupal_prepare_form(), but form
+      // during self::retrieveForm()/self::prepareForm(), but form
     // processing should not depend on whether the form is cached or not, so
     // $form_state is adjusted to match what it would be after a
-    // form_set_cache()/form_get_cache() sequence. These exceptions are
+      // self::setCache()/self::getCache() sequence. These exceptions are
     // allowed to survive here:
     // - always_process: Does not make sense in conjunction with form caching
     //   in the first place, since passing form_build_id as a GET parameter is
@@ -324,7 +130,7 @@ function drupal_build_form($form_id, &$f
     // - temporary: Any assigned data is expected to survives within the same
     //   page request.
     if ($check_cache) {
-      $uncacheable_keys = array_flip(array_diff(form_state_keys_no_cache(), array('always_process', 'temporary')));
+        $uncacheable_keys = array_flip(array_diff($this->getUncacheableKeys(), array('always_process', 'temporary')));
       $form_state = array_diff_key($form_state, $uncacheable_keys);
       $form_state += $form_state_before_retrieval;
     }
@@ -341,15 +147,15 @@ function drupal_build_form($form_id, &$f
   //   appropriate information persists to the next page request.
   // All of the handlers in the pipeline receive $form_state by reference and
   // can use it to know or update information about the state of the form.
-  $response = drupal_process_form($form_id, $form, $form_state);
+    $response = $this->processForm($form_id, $form, $form_state);
 
   // If the form returns some kind of response, deliver it.
   if ($response instanceof Response) {
-    _drupal_form_send_response($response);
+      $this->sendResponse($response);
   }
 
   // If this was a successful submission of a single-step form or the last step
-  // of a multi-step form, then drupal_process_form() issued a redirect to
+    // of a multi-step form, then self::processForm() issued a redirect to
   // another page, or back to this page, but as a new request. Therefore, if
   // we're here, it means that this is either a form being viewed initially
   // before any user input, or there was a validation error requiring the form
@@ -360,15 +166,15 @@ function drupal_build_form($form_id, &$f
 }
 
 /**
- * Retrieves default values for the $form_state array.
+   * {@inheritdoc}
  */
-function form_state_defaults() {
+  public function getFormStateDefaults() {
   return array(
     'rebuild' => FALSE,
     'rebuild_info' => array(),
     'redirect' => NULL,
     // @todo 'args' is usually set, so no other default 'build_info' keys are
-    //   appended via += form_state_defaults().
+      //   appended via += $this->getFormStateDefaults().
     'build_info' => array(
       'args' => array(),
       'files' => array(),
@@ -385,47 +191,10 @@ function form_state_defaults() {
 }
 
 /**
- * Constructs a new $form from the information in $form_state.
- *
- * This is the key function for making multi-step forms advance from step to
- * step. It is called by drupal_process_form() when all user input processing,
- * including calling validation and submission handlers, for the request is
- * finished. If a validate or submit handler set $form_state['rebuild'] to TRUE,
- * and if other conditions don't preempt a rebuild from happening, then this
- * function is called to generate a new $form, the next step in the form
- * workflow, to be returned for rendering.
- *
- * Ajax form submissions are almost always multi-step workflows, so that is one
- * common use-case during which form rebuilding occurs. See
- * Drupal\system\FormAjaxController::content() for more information about
- * creating Ajax-enabled forms.
- *
- * @param $form_id
- *   The unique string identifying the desired form. If a function
- *   with that name exists, it is called to build the form array.
- *   Modules that need to generate the same form (or very similar forms)
- *   using different $form_ids can implement hook_forms(), which maps
- *   different $form_id values to the proper form constructor function. Examples
- *   may be found in node_forms() and search_forms().
- * @param $form_state
- *   A keyed array containing the current state of the form.
- * @param $old_form
- *   (optional) A previously built $form. Used to retain the #build_id and
- *   #action properties in Ajax callbacks and similar partial form rebuilds. The
- *   only properties copied from $old_form are the ones which both exist in
- *   $old_form and for which $form_state['rebuild_info']['copy'][PROPERTY] is
- *   TRUE. If $old_form is not passed, the entire $form is rebuilt freshly.
- *   'rebuild_info' needs to be a separate top-level property next to
- *   'build_info', since the contained data must not be cached.
- *
- * @return
- *   The newly built form.
- *
- * @see drupal_process_form()
- * @see \Drupal\system\FormAjaxController::content()
+   * {@inheritdoc}
  */
-function drupal_rebuild_form($form_id, &$form_state, $old_form = NULL) {
-  $form = drupal_retrieve_form($form_id, $form_state);
+  public function rebuildForm($form_id, &$form_state, $old_form = NULL) {
+    $form = $this->retrieveForm($form_id, $form_state);
 
   // If only parts of the form will be returned to the browser (e.g., Ajax or
   // RIA clients), re-use the old #build_id to not require client-side code to
@@ -433,7 +202,7 @@ function drupal_rebuild_form($form_id, &
   // Otherwise, a new #build_id is generated, to not clobber the previous
   // build's data in the form cache; also allowing the user to go back to an
   // earlier build, make changes, and re-submit.
-  // @see drupal_prepare_form()
+    // @see self::prepareForm()
   if (isset($old_form['#build_id']) && !empty($form_state['rebuild_info']['copy']['#build_id'])) {
     $form['#build_id'] = $old_form['#build_id'];
   }
@@ -448,14 +217,14 @@ function drupal_rebuild_form($form_id, &
     $form['#action'] = $old_form['#action'];
   }
 
-  drupal_prepare_form($form_id, $form, $form_state);
+    $this->prepareForm($form_id, $form, $form_state);
 
-  // Caching is normally done in drupal_process_form(), but what needs to be
-  // cached is the $form structure before it passes through form_builder(),
+    // Caching is normally done in self::processForm(), but what needs to be
+    // cached is the $form structure before it passes through self::doBuildForm(),
   // so we need to do it here.
   // @todo For Drupal 8, find a way to avoid this code duplication.
   if (empty($form_state['no_cache'])) {
-    form_set_cache($form['#build_id'], $form, $form_state);
+      $this->setCache($form['#build_id'], $form, $form_state);
   }
 
   // Clear out all group associations as these might be different when
@@ -463,17 +232,17 @@ function drupal_rebuild_form($form_id, &
   $form_state['groups'] = array();
 
   // Return a fully built form that is ready for rendering.
-  return form_builder($form_id, $form, $form_state);
+    return $this->doBuildForm($form_id, $form, $form_state);
 }
 
 /**
- * Fetches a form from the cache.
+   * {@inheritdoc}
  */
-function form_get_cache($form_build_id, &$form_state) {
-  if ($form = \Drupal::keyValueExpirable('form')->get($form_build_id)) {
-    global $user;
-    if ((isset($form['#cache_token']) && drupal_valid_token($form['#cache_token'])) || (!isset($form['#cache_token']) && $user->isAnonymous())) {
-      if ($stored_form_state = \Drupal::keyValueExpirable('form_state')->get($form_build_id)) {
+  public function getCache($form_build_id, &$form_state) {
+    if ($form = $this->keyValueExpirableFactory->get('form')->get($form_build_id)) {
+      $user = $this->currentUser();
+      if ((isset($form['#cache_token']) && $this->csrfToken->validate($form['#cache_token'])) || (!isset($form['#cache_token']) && $user->isAnonymous())) {
+        if ($stored_form_state = $this->keyValueExpirableFactory->get('form_state')->get($form_build_id)) {
         // Re-populate $form_state for subsequent rebuilds.
         $form_state = $stored_form_state + $form_state;
 
@@ -483,7 +252,7 @@ function form_get_cache($form_build_id, 
         foreach ($form_state['build_info']['files'] as $file) {
           if (is_array($file)) {
             $file += array('type' => 'inc', 'name' => $file['module']);
-            module_load_include($file['type'], $file['module'], $file['name']);
+              $this->moduleHandler->loadInclude($file['module'], $file['type'], $file['name']);
           }
           elseif (file_exists($file)) {
             require_once DRUPAL_ROOT . '/' . $file;
@@ -496,30 +265,30 @@ function form_get_cache($form_build_id, 
 }
 
 /**
- * Stores a form in the cache.
+   * {@inheritdoc}
  */
-function form_set_cache($form_build_id, $form, $form_state) {
+  public function setCache($form_build_id, $form, $form_state) {
   // 6 hours cache life time for forms should be plenty.
   $expire = 21600;
 
   // Cache form structure.
   if (isset($form)) {
-    if ($GLOBALS['user']->isAuthenticated()) {
-      $form['#cache_token'] = drupal_get_token();
+      if ($this->currentUser()->isAuthenticated()) {
+        $form['#cache_token'] = $this->csrfToken->get();
     }
-    \Drupal::keyValueExpirable('form')->setWithExpire($form_build_id, $form, $expire);
+      $this->keyValueExpirableFactory->get('form')->setWithExpire($form_build_id, $form, $expire);
   }
 
   // Cache form state.
-  if ($data = array_diff_key($form_state, array_flip(form_state_keys_no_cache()))) {
-    \Drupal::keyValueExpirable('form_state')->setWithExpire($form_build_id, $data, $expire);
+    if ($data = array_diff_key($form_state, array_flip($this->getUncacheableKeys()))) {
+      $this->keyValueExpirableFactory->get('form_state')->setWithExpire($form_build_id, $data, $expire);
   }
 }
 
 /**
  * Returns an array of $form_state keys that shouldn't be cached.
  */
-function form_state_keys_no_cache() {
+  protected function getUncacheableKeys() {
   return array(
     // Public properties defined by form constructors and form handlers.
     'always_process',
@@ -545,62 +314,9 @@ function form_state_keys_no_cache() {
 }
 
 /**
- * Retrieves, populates, and processes a form.
- *
- * This function allows you to supply values for form elements and submit a
- * form for processing. Compare to drupal_get_form(), which also builds and
- * processes a form, but does not allow you to supply values.
- *
- * There is no return value, but you can check to see if there are errors
- * by calling form_get_errors().
- *
- * @param \Drupal\Core\Form\FormInterface|string $form_arg
- *   A form object to use to build the form, or the unique string identifying
- *   the desired form. If $form_arg is a string and a function with that
- *   name exists, it is called to build the form array. Modules that need to
- *   generate the same form (or very similar forms) using different $form_ids
- *   can implement hook_forms(), which maps different $form_id values to the
- *   proper form constructor function. Examples may be found in node_forms()
- *   and search_forms().
- * @param $form_state
- *   A keyed array containing the current state of the form. Most important is
- *   the $form_state['values'] collection, a tree of data used to simulate the
- *   incoming $_POST information from a user's form submission. If a key is not
- *   filled in $form_state['values'], then the default value of the respective
- *   element is used. To submit an unchecked checkbox or other control that
- *   browsers submit by not having a $_POST entry, include the key, but set the
- *   value to NULL.
- * @param ...
- *   Any additional arguments are passed on to the functions called by
- *   drupal_form_submit(), including the unique form constructor function.
- *   For example, the node_edit form requires that a node object be passed
- *   in here when it is called. Arguments that need to be passed by reference
- *   should not be included here, but rather placed directly in the $form_state
- *   build info array so that the reference can be preserved. For example, a
- *   form builder function with the following signature:
- *   @code
- *   function mymodule_form($form, &$form_state, &$object) {
- *   }
- *   @endcode
- *   would be called via drupal_form_submit() as follows:
- *   @code
- *   $form_state['values'] = $my_form_values;
- *   $form_state['build_info']['args'] = array(&$object);
- *   drupal_form_submit('mymodule_form', $form_state);
- *   @endcode
- * For example:
- * @code
- * // register a new user
- * $form_state = array();
- * $form_state['values']['name'] = 'robo-user';
- * $form_state['values']['mail'] = 'robouser@example.com';
- * $form_state['values']['pass']['pass1'] = 'password';
- * $form_state['values']['pass']['pass2'] = 'password';
- * $form_state['values']['op'] = t('Create new account');
- * drupal_form_submit('user_register_form', $form_state);
- * @endcode
+   * {@inheritdoc}
  */
-function drupal_form_submit($form_arg, &$form_state) {
+  public function submitForm($form_arg, &$form_state) {
   if (!isset($form_state['build_info']['args'])) {
     $args = func_get_args();
     array_shift($args);
@@ -608,60 +324,47 @@ function drupal_form_submit($form_arg, &
     $form_state['build_info']['args'] = $args;
   }
   // Merge in default values.
-  $form_state += form_state_defaults();
+    $form_state += $this->getFormStateDefaults();
 
   // Populate $form_state['input'] with the submitted values before retrieving
-  // the form, to be consistent with what drupal_build_form() does for
+    // the form, to be consistent with what self::buildForm() does for
   // non-programmatic submissions (form builder functions may expect it to be
   // there).
   $form_state['input'] = $form_state['values'];
 
   $form_state['programmed'] = TRUE;
 
-  $form_id = _drupal_form_id($form_arg, $form_state);
-  $form = drupal_retrieve_form($form_id, $form_state);
+    $form_id = $this->getFormId($form_arg, $form_state);
+    $form = $this->retrieveForm($form_id, $form_state);
   // Programmed forms are always submitted.
   $form_state['submitted'] = TRUE;
 
   // Reset form validation.
   $form_state['must_validate'] = TRUE;
-  form_clear_error();
+    $this->clearErrors();
 
-  drupal_prepare_form($form_id, $form, $form_state);
-  drupal_process_form($form_id, $form, $form_state);
+    $this->prepareForm($form_id, $form, $form_state);
+    $this->processForm($form_id, $form, $form_state);
 }
 
 /**
- * Retrieves the structured array that defines a given form.
- *
- * @param $form_id
- *   The unique string identifying the desired form. If a function
- *   with that name exists, it is called to build the form array.
- *   Modules that need to generate the same form (or very similar forms)
- *   using different $form_ids can implement hook_forms(), which maps
- *   different $form_id values to the proper form constructor function.
- * @param $form_state
- *   A keyed array containing the current state of the form, including the
- *   additional arguments to drupal_get_form() or drupal_form_submit() in the
- *   'args' component of the array.
+   * {@inheritdoc}
  */
-function drupal_retrieve_form($form_id, &$form_state) {
-  $forms = &drupal_static(__FUNCTION__);
-
+  public function retrieveForm($form_id, &$form_state) {
   // Record the $form_id.
   $form_state['build_info']['form_id'] = $form_id;
 
   // Record the filepath of the include file containing the original form, so
   // the form builder callbacks can be loaded when the form is being rebuilt
   // from cache on a different path (such as 'system/ajax'). See
-  // form_get_cache(). Don't do this in maintenance mode as Drupal may not be
+    // self::getCache(). Don't do this in maintenance mode as Drupal may not be
   // fully bootstrapped (i.e. during installation) in which case
   // menu_get_item() is not available.
   if (!isset($form_state['build_info']['files']['menu']) && !defined('MAINTENANCE_MODE')) {
-    $item = menu_get_item();
+      $item = $this->menuGetItem();
     if (!empty($item['include_file'])) {
       // Do not use form_load_include() here, as the file is already loaded.
-      // Anyway, form_get_cache() is able to handle filepaths too.
+        // Anyway, self::getCache() is able to handle filepaths too.
       $form_state['build_info']['files']['menu'] = $item['include_file'];
     }
   }
@@ -693,12 +396,12 @@ function drupal_retrieve_form($form_id, 
     // adds a small 'rate this comment' form to each comment in a list
     // would need a unique form_id for each one, for example.)
     //
-    // So, we call the hook if $forms isn't yet populated, OR if it doesn't
+      // So, we call the hook if $this->forms isn't yet populated, OR if it doesn't
     // yet have an entry for the requested form_id.
-    if (!isset($forms) || !isset($forms[$form_id])) {
-      $forms = \Drupal::moduleHandler()->invokeAll('forms', array($form_id, $args));
+      if (!isset($this->forms) || !isset($this->forms[$form_id])) {
+        $this->forms = $this->moduleHandler->invokeAll('forms', array($form_id, $args));
     }
-    $form_definition = $forms[$form_id];
+      $form_definition = $this->forms[$form_id];
     if (isset($form_definition['callback arguments'])) {
       $args = array_merge($form_definition['callback arguments'], $args);
     }
@@ -715,12 +418,12 @@ function drupal_retrieve_form($form_id, 
 
   $form = array();
   // Assign a default CSS class name based on $form_id.
-  // This happens here and not in drupal_prepare_form() in order to allow the
+    // This happens here and not in self::prepareForm() in order to allow the
   // form constructor function to override or remove the default class.
-  $form['#attributes']['class'][] = drupal_html_class($form_id);
+    $form['#attributes']['class'][] = $this->drupalHtmlClass($form_id);
   // Same for the base form ID, if any.
   if (isset($form_state['build_info']['base_form_id'])) {
-    $form['#attributes']['class'][] = drupal_html_class($form_state['build_info']['base_form_id']);
+      $form['#attributes']['class'][] = $this->drupalHtmlClass($form_state['build_info']['base_form_id']);
   }
 
   // We need to pass $form_state by reference in order for forms to modify it,
@@ -728,12 +431,12 @@ function drupal_retrieve_form($form_id, 
   // explicitly.
   $args = array_merge(array($form, &$form_state), $args);
 
-  // When the passed $form_state (not using drupal_get_form()) defines a
+    // When the passed $form_state (not using self::getForm()) defines a
   // 'wrapper_callback', then it requests to invoke a separate (wrapping) form
   // builder function to pre-populate the $form array with form elements, which
   // the actual form builder function ($callback) expects. This allows for
   // pre-populating a form with common elements for certain forms, such as
-  // back/next/save buttons in multi-step form wizards. See drupal_build_form().
+    // back/next/save buttons in multi-step form wizards. See self::buildForm().
   if (isset($form_state['wrapper_callback'])) {
     $form = call_user_func_array($form_state['wrapper_callback'], $args);
     // Put the prepopulated $form into $args.
@@ -745,7 +448,7 @@ function drupal_retrieve_form($form_id, 
   $form = call_user_func_array($callback, $args);
   // If the form returns some kind of response, deliver it.
   if ($form instanceof Response) {
-    _drupal_form_send_response($form);
+      $this->sendResponse($form);
   }
   $form['#form_id'] = $form_id;
 
@@ -753,23 +456,9 @@ function drupal_retrieve_form($form_id, 
 }
 
 /**
- * Processes a form submission.
- *
- * This function is the heart of form API. The form gets built, validated and in
- * appropriate cases, submitted and rebuilt.
- *
- * @param $form_id
- *   The unique string identifying the current form.
- * @param $form
- *   An associative array containing the structure of the form.
- * @param $form_state
- *   A keyed array containing the current state of the form. This
- *   includes the current persistent storage data for the form, and
- *   any data passed along by earlier steps when displaying a
- *   multi-step form. Additional information, like the sanitized $_POST
- *   data, is also accumulated here.
+   * {@inheritdoc}
  */
-function drupal_process_form($form_id, &$form, &$form_state) {
+  public function processForm($form_id, &$form, &$form_state) {
   $form_state['values'] = array();
 
   // With $_GET, these forms are always submitted if requested.
@@ -781,47 +470,47 @@ function drupal_process_form($form_id, &
       $form_state['input']['form_id'] = $form_id;
     }
     if (!isset($form_state['input']['form_token']) && isset($form['#token'])) {
-      $form_state['input']['form_token'] = drupal_get_token($form['#token']);
+        $form_state['input']['form_token'] = $this->csrfToken->get($form['#token']);
     }
   }
 
-  // form_builder() finishes building the form by calling element #process
+    // self::doBuildForm() finishes building the form by calling element #process
   // functions and mapping user input, if any, to #value properties, and also
   // storing the values in $form_state['values']. We need to retain the
   // unprocessed $form in case it needs to be cached.
   $unprocessed_form = $form;
-  $form = form_builder($form_id, $form, $form_state);
+    $form = $this->doBuildForm($form_id, $form, $form_state);
 
   // Only process the input if we have a correct form submission.
   if ($form_state['process_input']) {
-    drupal_validate_form($form_id, $form, $form_state);
+      $this->validateForm($form_id, $form, $form_state);
 
     // drupal_html_id() maintains a cache of element IDs it has seen,
     // so it can prevent duplicates. We want to be sure we reset that
     // cache when a form is processed, so scenarios that result in
     // the form being built behind the scenes and again for the
     // browser don't increment all the element IDs needlessly.
-    if (!form_get_errors()) {
+      if (!$this->getErrors()) {
       // In case of errors, do not break HTML IDs of other forms.
-      drupal_static_reset('drupal_html_id');
+        $this->drupalStaticReset('drupal_html_id');
     }
 
-    if ($form_state['submitted'] && !form_get_errors() && !$form_state['rebuild']) {
+      if ($form_state['submitted'] && !$this->getErrors() && !$form_state['rebuild']) {
       // Execute form submit handlers.
-      form_execute_handlers('submit', $form, $form_state);
+        $this->executeHandlers('submit', $form, $form_state);
 
       // If batches were set in the submit handlers, we process them now,
       // possibly ending execution. We make sure we do not react to the batch
       // that is already being processed (if a batch operation performs a
-      // drupal_form_submit).
+        // self::submitForm).
       if ($batch =& batch_get() && !isset($batch['current_set'])) {
         // Store $form_state information in the batch definition.
         // We need the full $form_state when either:
         // - Some submit handlers were saved to be called during batch
-        //   processing. See form_execute_handlers().
+          //   processing. See self::executeHandlers().
         // - The form is multistep.
         // In other cases, we only need the information expected by
-        // drupal_redirect_form().
+          // self::redirectForm().
         if ($batch['has_form_submits'] || !empty($form_state['rebuild'])) {
           $batch['form_state'] = $form_state;
         }
@@ -845,13 +534,13 @@ function drupal_process_form($form_id, &
       $form_state['executed'] = TRUE;
 
       // Redirect the form based on values in $form_state.
-      $redirect = drupal_redirect_form($form_state);
+        $redirect = $this->redirectForm($form_state);
       if (is_object($redirect)) {
         return $redirect;
       }
     }
 
-    // Don't rebuild or cache form submissions invoked via drupal_form_submit().
+      // Don't rebuild or cache form submissions invoked via self::submitForm().
     if (!empty($form_state['programmed'])) {
       return;
     }
@@ -871,44 +560,32 @@ function drupal_process_form($form_id, &
     //   along with element-level #submit properties, it makes no sense to have
     //   divergent form execution based on whether the triggering element has
     //   #executes_submit_callback set to TRUE.
-    if (($form_state['rebuild'] || !$form_state['executed']) && !form_get_errors()) {
-      // Form building functions (e.g., _form_builder_handle_input_element())
+      if (($form_state['rebuild'] || !$form_state['executed']) && !$this->getErrors()) {
+        // Form building functions (e.g., self::handleInputElement())
       // may use $form_state['rebuild'] to determine if they are running in the
       // context of a rebuild, so ensure it is set.
       $form_state['rebuild'] = TRUE;
-      $form = drupal_rebuild_form($form_id, $form_state, $form);
+        $form = $this->rebuildForm($form_id, $form_state, $form);
     }
   }
 
   // After processing the form, the form builder or a #process callback may
   // have set $form_state['cache'] to indicate that the form and form state
   // shall be cached. But the form may only be cached if the 'no_cache' property
-  // is not set to TRUE. Only cache $form as it was prior to form_builder(),
-  // because form_builder() must run for each request to accommodate new user
-  // input. Rebuilt forms are not cached here, because drupal_rebuild_form()
+    // is not set to TRUE. Only cache $form as it was prior to self::doBuildForm(),
+    // because self::doBuildForm() must run for each request to accommodate new user
+    // input. Rebuilt forms are not cached here, because self::rebuildForm()
   // already takes care of that.
   if (!$form_state['rebuild'] && $form_state['cache'] && empty($form_state['no_cache'])) {
-    form_set_cache($form['#build_id'], $unprocessed_form, $form_state);
+      $this->setCache($form['#build_id'], $unprocessed_form, $form_state);
   }
 }
 
 /**
- * Prepares a structured form array.
- *
- * Adds required elements, executes any hook_form_alter functions, and
- * optionally inserts a validation token to prevent tampering.
- *
- * @param $form_id
- *   A unique string identifying the form for validation, submission,
- *   theming, and hook_form_alter functions.
- * @param $form
- *   An associative array containing the structure of the form.
- * @param $form_state
- *   A keyed array containing the current state of the form. Passed
- *   in here so that hook_form_alter() calls can use it, as well.
+   * {@inheritdoc}
  */
-function drupal_prepare_form($form_id, &$form, &$form_state) {
-  global $user;
+  public function prepareForm($form_id, &$form, &$form_state) {
+    $user = $this->currentUser();
 
   $form['#type'] = 'form';
   $form_state['programmed'] = isset($form_state['programmed']) ? $form_state['programmed'] : FALSE;
@@ -922,8 +599,8 @@ function drupal_prepare_form($form_id, &
   // form_build_id is used as key to cache a particular build of the form. For
   // multi-step forms, this allows the user to go back to an earlier build, make
   // changes, and re-submit.
-  // @see drupal_build_form()
-  // @see drupal_rebuild_form()
+    // @see self::buildForm()
+    // @see self::rebuildForm()
   if (!isset($form['#build_id'])) {
     $form['#build_id'] = 'form-' . Crypt::hashBase64(uniqid(mt_rand(), TRUE) . mt_rand());
   }
@@ -956,9 +633,9 @@ function drupal_prepare_form($form_id, &
     else {
       $form['#token'] = $form_id;
       $form['form_token'] = array(
-        '#id' => drupal_html_id('edit-' . $form_id . '-form-token'),
+          '#id' => $this->drupalHtmlId('edit-' . $form_id . '-form-token'),
         '#type' => 'token',
-        '#default_value' => drupal_get_token($form['#token']),
+          '#default_value' => $this->csrfToken->get($form['#token']),
         // Form processing and validation requires this value, so ensure the
         // submitted form value appears literally, regardless of custom #tree
         // and #parents being set elsewhere.
@@ -971,7 +648,7 @@ function drupal_prepare_form($form_id, &
     $form['form_id'] = array(
       '#type' => 'hidden',
       '#value' => $form_id,
-      '#id' => drupal_html_id("edit-$form_id"),
+        '#id' => $this->drupalHtmlId("edit-$form_id"),
       // Form processing and validation requires this value, so ensure the
       // submitted form value appears literally, regardless of custom #tree
       // and #parents being set elsewhere.
@@ -979,10 +656,10 @@ function drupal_prepare_form($form_id, &
     );
   }
   if (!isset($form['#id'])) {
-    $form['#id'] = drupal_html_id($form_id);
+      $form['#id'] = $this->drupalHtmlId($form_id);
   }
 
-  $form += element_info('form');
+    $form += $this->getElementInfo('form');
   $form += array('#tree' => FALSE, '#parents' => array());
 
   if (!isset($form['#validate'])) {
@@ -1037,57 +714,32 @@ function drupal_prepare_form($form_id, &
     $hooks[] = 'form_' . $form_state['build_info']['base_form_id'];
   }
   $hooks[] = 'form_' . $form_id;
-  drupal_alter($hooks, $form, $form_state, $form_id);
+    $this->moduleHandler->alter($hooks, $form, $form_state, $form_id);
 }
 
-
 /**
- * Validates user-submitted form data in the $form_state array.
- *
- * @param $form_id
- *   A unique string identifying the form for validation, submission,
- *   theming, and hook_form_alter functions.
- * @param $form
- *   An associative array containing the structure of the form, which is passed
- *   by reference. Form validation handlers are able to alter the form structure
- *   (like #process and #after_build callbacks during form building) in case of
- *   a validation error. If a validation handler alters the form structure, it
- *   is responsible for validating the values of changed form elements in
- *   $form_state['values'] to prevent form submit handlers from receiving
- *   unvalidated values.
- * @param $form_state
- *   A keyed array containing the current state of the form. The current
- *   user-submitted data is stored in $form_state['values'], though
- *   form validation functions are passed an explicit copy of the
- *   values for the sake of simplicity. Validation handlers can also use
- *   $form_state to pass information on to submit handlers. For example:
- *     $form_state['data_for_submission'] = $data;
- *   This technique is useful when validation requires file parsing,
- *   web service requests, or other expensive requests that should
- *   not be repeated in the submission step.
+   * {@inheritdoc}
  */
-function drupal_validate_form($form_id, &$form, &$form_state) {
-  $validated_forms = &drupal_static(__FUNCTION__, array());
-
-  if (isset($validated_forms[$form_id]) && empty($form_state['must_validate'])) {
+  public function validateForm($form_id, &$form, &$form_state) {
+    if (isset($this->validatedForms[$form_id]) && empty($form_state['must_validate'])) {
     return;
   }
 
-  // If the session token was set by drupal_prepare_form(), ensure that it
+    // If the session token was set by self::prepareForm(), ensure that it
   // matches the current user's session.
   if (isset($form['#token'])) {
-    if (!drupal_valid_token($form_state['values']['form_token'], $form['#token'])) {
-      $path = current_path();
-      $query = drupal_get_query_parameters();
-      $url = url($path, array('query' => $query));
+      if (!$this->csrfToken->validate($form_state['values']['form_token'], $form['#token'])) {
+        $path = $this->request->attributes->get('_system_path');
+        $query = Url::filterQueryParameters($this->request->query->all());
+        $url = $this->urlGenerator->generateFromPath($path, array('query' => $query));
 
       // Setting this error will cause the form to fail validation.
-      form_set_error('form_token', t('The form has become outdated. Copy any unsaved work in the form below and then <a href="@link">reload this page</a>.', array('@link' => $url)));
+        $this->setErrorByName('form_token', $this->t('The form has become outdated. Copy any unsaved work in the form below and then <a href="@link">reload this page</a>.', array('@link' => $url)));
     }
   }
 
-  _form_validate($form, $form_state, $form_id);
-  $validated_forms[$form_id] = TRUE;
+    $this->doValidateForm($form, $form_state, $form_id);
+    $this->validatedForms[$form_id] = TRUE;
 
   // If validation errors are limited then remove any non validated form values,
   // so that only values that passed validation are left for submit callbacks.
@@ -1117,7 +769,7 @@ function drupal_validate_form($form_id, 
         NestedArray::setValue($values, $parents, $button_value);
       }
 
-      // Additionally, form_builder() places the button value in
+        // Additionally, self::doBuildForm() places the button value in
       // $form_state['values'][BUTTON_NAME]. If it's still there, after
       // validation handlers have run, copy it to $values, but do not override
       // what may already be in $values.
@@ -1131,64 +783,10 @@ function drupal_validate_form($form_id, 
 }
 
 /**
- * Redirects the user to a URL after a form has been processed.
- *
- * After a form is submitted and processed, normally the user should be
- * redirected to a new destination page. This function figures out what that
- * destination should be, based on the $form_state array and the 'destination'
- * query string in the request URL, and redirects the user there.
- *
- * Usually (for exceptions, see below) $form_state['redirect'] determines where
- * to redirect the user. This can be set either to a string (the path to
- * redirect to), or an array of arguments for url(). If $form_state['redirect']
- * is missing, the user is usually (again, see below for exceptions) redirected
- * back to the page they came from, where they should see a fresh, unpopulated
- * copy of the form.
- *
- * Here is an example of how to set up a form to redirect to the path 'node':
- * @code
- * $form_state['redirect'] = 'node';
- * @endcode
- * And here is an example of how to redirect to 'node/123?foo=bar#baz':
- * @code
- * $form_state['redirect'] = array(
- *   'node/123',
- *   array(
- *     'query' => array(
- *       'foo' => 'bar',
- *     ),
- *     'fragment' => 'baz',
- *   ),
- * );
- * @endcode
- *
- * There are several exceptions to the "usual" behavior described above:
- * - If $form_state['programmed'] is TRUE, the form submission was usually
- *   invoked via drupal_form_submit(), so any redirection would break the script
- *   that invoked drupal_form_submit() and no redirection is done.
- * - If $form_state['rebuild'] is TRUE, the form is being rebuilt, and no
- *   redirection is done.
- * - If $form_state['no_redirect'] is TRUE, redirection is disabled. This is
- *   set, for instance, by \Drupal\system\FormAjaxController::getForm() to
- *   prevent redirection in Ajax callbacks. $form_state['no_redirect'] should
- *   never be set or altered by form builder functions or form validation/submit
- *   handlers.
- * - If $form_state['redirect'] is set to FALSE, redirection is disabled.
- * - If none of the above conditions has prevented redirection, then the
- *   redirect is accomplished by returning a RedirectResponse, passing in the
- *   value of $form_state['redirect'] if it is set, or the current path if it is
- *   not. RedirectResponse preferentially uses the value of $_GET['destination']
- *   (the 'destination' URL query string) if it is present, so this will
- *   override any values set by $form_state['redirect'].
- *
- * @param $form_state
- *   An associative array containing the current state of the form.
- *
- * @see drupal_process_form()
- * @see drupal_build_form()
+   * {@inheritdoc}
  */
-function drupal_redirect_form($form_state) {
-  // Skip redirection for form submissions invoked via drupal_form_submit().
+  public function redirectForm($form_state) {
+    // Skip redirection for form submissions invoked via self::submitForm().
   if (!empty($form_state['programmed'])) {
     return;
   }
@@ -1204,26 +802,36 @@ function drupal_redirect_form($form_stat
   if (!isset($form_state['redirect']) || $form_state['redirect'] !== FALSE) {
     if (isset($form_state['redirect'])) {
       if (is_array($form_state['redirect'])) {
-        $options = isset($form_state['redirect'][1]) ? $form_state['redirect'][1] : array();
+          if (isset($form_state['redirect'][1])) {
+            $options = $form_state['redirect'][1];
+          }
+          else {
+            $options = array();
+          }
         // Redirections should always use absolute URLs.
         $options['absolute'] = TRUE;
-        $status_code =  isset($form_state['redirect'][2]) ? $form_state['redirect'][2] : 302;
-        return new RedirectResponse(url($form_state['redirect'][0], $options), $status_code);
+          if (isset($form_state['redirect'][2])) {
+            $status_code = $form_state['redirect'][2];
+          }
+          else {
+            $status_code = 302;
+          }
+          return new RedirectResponse($this->urlGenerator->generateFromPath($form_state['redirect'][0], $options), $status_code);
       }
       else {
         // This function can be called from the installer, which guarantees
         // that $redirect will always be a string, so catch that case here
         // and use the appropriate redirect function.
-        if (drupal_installation_attempted()) {
+          if ($this->drupalInstallationAttempted()) {
           install_goto($form_state['redirect']);
         }
         else {
-          return new RedirectResponse(url($form_state['redirect'], array('absolute' => TRUE)));
+            return new RedirectResponse($this->urlGenerator->generateFromPath($form_state['redirect'], array('absolute' => TRUE)));
         }
       }
     }
-    $url = url(\Drupal::request()->attributes->get('_system_path'), array(
-      'query' => \Drupal::request()->query->all(),
+      $url = $this->urlGenerator->generateFromPath($this->request->attributes->get('_system_path'), array(
+        'query' => $this->request->query->all(),
       'absolute' => TRUE,
     ));
     return new RedirectResponse($url);
@@ -1253,11 +861,11 @@ function drupal_redirect_form($form_stat
  *   A unique string identifying the form for validation, submission,
  *   theming, and hook_form_alter functions.
  */
-function _form_validate(&$elements, &$form_state, $form_id = NULL) {
+  protected function doValidateForm(&$elements, &$form_state, $form_id = NULL) {
   // Recurse through all children.
-  foreach (element_children($elements) as $key) {
+    foreach ($this->elementChildren($elements) as $key) {
     if (isset($elements[$key]) && $elements[$key]) {
-      _form_validate($elements[$key], $form_state);
+        $this->doValidateForm($elements[$key], $form_state);
     }
   }
 
@@ -1266,8 +874,8 @@ function _form_validate(&$elements, &$fo
     // The following errors are always shown.
     if (isset($elements['#needs_validation'])) {
       // Verify that the value is not longer than #maxlength.
-      if (isset($elements['#maxlength']) && drupal_strlen($elements['#value']) > $elements['#maxlength']) {
-        form_error($elements, t('!name cannot be longer than %max characters but is currently %length characters long.', array('!name' => empty($elements['#title']) ? $elements['#parents'][0] : $elements['#title'], '%max' => $elements['#maxlength'], '%length' => drupal_strlen($elements['#value']))));
+        if (isset($elements['#maxlength']) && Unicode::strlen($elements['#value']) > $elements['#maxlength']) {
+          $this->setError($elements, $this->t('!name cannot be longer than %max characters but is currently %length characters long.', array('!name' => empty($elements['#title']) ? $elements['#parents'][0] : $elements['#title'], '%max' => $elements['#maxlength'], '%length' => Unicode::strlen($elements['#value']))));
       }
 
       if (isset($elements['#options']) && isset($elements['#value'])) {
@@ -1281,8 +889,8 @@ function _form_validate(&$elements, &$fo
           $value = in_array($elements['#type'], array('checkboxes', 'tableselect')) ? array_keys($elements['#value']) : $elements['#value'];
           foreach ($value as $v) {
             if (!isset($options[$v])) {
-              form_error($elements, t('An illegal choice has been detected. Please contact the site administrator.'));
-              watchdog('form', 'Illegal choice %choice in !name element.', array('%choice' => $v, '!name' => empty($elements['#title']) ? $elements['#parents'][0] : $elements['#title']), WATCHDOG_ERROR);
+                $this->setError($elements, $this->t('An illegal choice has been detected. Please contact the site administrator.'));
+                $this->watchdog('form', 'Illegal choice %choice in !name element.', array('%choice' => $v, '!name' => empty($elements['#title']) ? $elements['#parents'][0] : $elements['#title']), WATCHDOG_ERROR);
             }
           }
         }
@@ -1297,17 +905,17 @@ function _form_validate(&$elements, &$fo
         // @see form_process_select()
         elseif ($elements['#type'] == 'select' && !$elements['#multiple'] && $elements['#required'] && !isset($elements['#default_value']) && $elements['#value'] === $elements['#empty_value']) {
           $elements['#value'] = NULL;
-          form_set_value($elements, NULL, $form_state);
+            $this->setValue($elements, NULL, $form_state);
         }
         elseif (!isset($options[$elements['#value']])) {
-          form_error($elements, t('An illegal choice has been detected. Please contact the site administrator.'));
-          watchdog('form', 'Illegal choice %choice in %name element.', array('%choice' => $elements['#value'], '%name' => empty($elements['#title']) ? $elements['#parents'][0] : $elements['#title']), WATCHDOG_ERROR);
+            $this->setError($elements, $this->t('An illegal choice has been detected. Please contact the site administrator.'));
+            $this->watchdog('form', 'Illegal choice %choice in %name element.', array('%choice' => $elements['#value'], '%name' => empty($elements['#title']) ? $elements['#parents'][0] : $elements['#title']), WATCHDOG_ERROR);
         }
       }
     }
 
     // While this element is being validated, it may be desired that some calls
-    // to form_set_error() be suppressed and not result in a form error, so
+      // to self::setErrorByName() be suppressed and not result in a form error, so
     // that a button that implements low-risk functionality (such as "Previous"
     // or "Add more") that doesn't require all user input to be valid can still
     // have its submit handlers triggered. The triggering element's
@@ -1318,7 +926,7 @@ function _form_validate(&$elements, &$fo
     // security risk to have any invalid user input when executing form-level
     // submit handlers.
     if (isset($form_state['triggering_element']['#limit_validation_errors']) && ($form_state['triggering_element']['#limit_validation_errors'] !== FALSE) && !($form_state['submitted'] && !isset($form_state['triggering_element']['#submit']))) {
-      form_set_error(NULL, '', $form_state['triggering_element']['#limit_validation_errors']);
+        $this->setErrorByName(NULL, '', $form_state['triggering_element']['#limit_validation_errors']);
     }
     // If submit handlers won't run (due to the submission having been triggered
     // by an element whose #executes_submit_callback property isn't TRUE), then
@@ -1329,14 +937,14 @@ function _form_validate(&$elements, &$fo
     // #limit_validation_errors defaults to FALSE (via system_element_info()),
     // so that full validation is their default behavior.
     elseif (isset($form_state['triggering_element']) && !isset($form_state['triggering_element']['#limit_validation_errors']) && !$form_state['submitted']) {
-      form_set_error(NULL, '', array());
+        $this->setErrorByName(NULL, '', array());
     }
     // As an extra security measure, explicitly turn off error suppression if
     // one of the above conditions wasn't met. Since this is also done at the
     // end of this function, doing it here is only to handle the rare edge case
     // where a validate handler invokes form processing of another form.
     else {
-      drupal_static_reset('form_set_error:limit_validation_errors');
+        $this->errorSections = NULL;
     }
 
     // Make sure a value is passed when the field is required.
@@ -1347,7 +955,7 @@ function _form_validate(&$elements, &$fo
       // An unchecked checkbox has a #value of integer 0, different than string
       // '0', which could be a valid value.
       $is_empty_multiple = (!count($elements['#value']));
-      $is_empty_string = (is_string($elements['#value']) && drupal_strlen(trim($elements['#value'])) == 0);
+        $is_empty_string = (is_string($elements['#value']) && Unicode::strlen(trim($elements['#value'])) == 0);
       $is_empty_value = ($elements['#value'] === 0);
       if ($is_empty_multiple || $is_empty_string || $is_empty_value) {
         // Flag this element as #required_but_empty to allow #element_validate
@@ -1360,7 +968,7 @@ function _form_validate(&$elements, &$fo
 
     // Call user-defined form level validators.
     if (isset($form_id)) {
-      form_execute_handlers('validate', $elements, $form_state);
+        $this->executeHandlers('validate', $elements, $form_state);
     }
     // Call any element-specific validators. These must act on the element
     // #value data.
@@ -1376,17 +984,17 @@ function _form_validate(&$elements, &$fo
     // variables are also known to be defined and we can test them again.
     if (isset($is_empty_value) && ($is_empty_multiple || $is_empty_string || $is_empty_value)) {
       if (isset($elements['#required_error'])) {
-        form_error($elements, $elements['#required_error']);
+          $this->setError($elements, $elements['#required_error']);
       }
       // A #title is not mandatory for form elements, but without it we cannot
       // set a form error message. So when a visible title is undesirable, form
       // constructors are encouraged to set #title anyway, and then set
       // #title_display to 'invisible'. This improves accessibility.
       elseif (isset($elements['#title'])) {
-        form_error($elements, t('!name field is required.', array('!name' => $elements['#title'])));
+          $this->setError($elements, $this->t('!name field is required.', array('!name' => $elements['#title'])));
       }
       else {
-        form_error($elements);
+          $this->setError($elements);
       }
     }
 
@@ -1394,28 +1002,15 @@ function _form_validate(&$elements, &$fo
   }
 
   // Done validating this element, so turn off error suppression.
-  // _form_validate() turns it on again when starting on the next element, if
+    // self::doValidateForm() turns it on again when starting on the next element, if
   // it's still appropriate to do so.
-  drupal_static_reset('form_set_error:limit_validation_errors');
+    $this->errorSections = NULL;
 }
 
 /**
- * Executes custom validation and submission handlers for a given form.
- *
- * Button-specific handlers are checked first. If none exist, the function
- * falls back to form-level handlers.
- *
- * @param $type
- *   The type of handler to execute. 'validate' or 'submit' are the
- *   defaults used by Form API.
- * @param $form
- *   An associative array containing the structure of the form.
- * @param $form_state
- *   A keyed array containing the current state of the form. If the user
- *   submitted the form by clicking a button with custom handler functions
- *   defined, those handlers will be stored here.
+   * {@inheritdoc}
  */
-function form_execute_handlers($type, &$form, &$form_state) {
+  public function executeHandlers($type, &$form, &$form_state) {
   // If there was a button pressed, use its handlers.
   if (isset($form_state[$type . '_handlers'])) {
     $handlers = $form_state[$type . '_handlers'];
@@ -1431,7 +1026,7 @@ function form_execute_handlers($type, &$
   foreach ($handlers as $function) {
     // Check if a previous _submit handler has set a batch, but make sure we
     // do not react to a batch that is already being processed (for instance
-    // if a batch operation performs a drupal_form_submit()).
+      // if a batch operation performs a self::submitForm()).
     if ($type == 'submit' && ($batch =& batch_get()) && !isset($batch['id'])) {
       // Some previous submit handler has set a batch. To ensure correct
       // execution order, store the call in a special 'control' batch set.
@@ -1446,111 +1041,16 @@ function form_execute_handlers($type, &$
 }
 
 /**
- * Files an error against a form element.
- *
- * When a validation error is detected, the validator calls form_set_error() to
- * indicate which element needs to be changed and provide an error message. This
- * causes the Form API to not execute the form submit handlers, and instead to
- * re-display the form to the user with the corresponding elements rendered with
- * an 'error' CSS class (shown as red by default).
- *
- * The standard form_set_error() behavior can be changed if a button provides
- * the #limit_validation_errors property. Multistep forms not wanting to
- * validate the whole form can set #limit_validation_errors on buttons to
- * limit validation errors to only certain elements. For example, pressing the
- * "Previous" button in a multistep form should not fire validation errors just
- * because the current step has invalid values. If #limit_validation_errors is
- * set on a clicked button, the button must also define a #submit property
- * (may be set to an empty array). Any #submit handlers will be executed even if
- * there is invalid input, so extreme care should be taken with respect to any
- * actions taken by them. This is typically not a problem with buttons like
- * "Previous" or "Add more" that do not invoke persistent storage of the
- * submitted form values. Do not use the #limit_validation_errors property on
- * buttons that trigger saving of form values to the database.
- *
- * The #limit_validation_errors property is a list of "sections" within
- * $form_state['values'] that must contain valid values. Each "section" is an
- * array with the ordered set of keys needed to reach that part of
- * $form_state['values'] (i.e., the #parents property of the element).
- *
- * Example 1: Allow the "Previous" button to function, regardless of whether any
- * user input is valid.
- *
- * @code
- *   $form['actions']['previous'] = array(
- *     '#type' => 'submit',
- *     '#value' => t('Previous'),
- *     '#limit_validation_errors' => array(),       // No validation.
- *     '#submit' => array('some_submit_function'),  // #submit required.
- *   );
- * @endcode
- *
- * Example 2: Require some, but not all, user input to be valid to process the
- * submission of a "Previous" button.
- *
- * @code
- *   $form['actions']['previous'] = array(
- *     '#type' => 'submit',
- *     '#value' => t('Previous'),
- *     '#limit_validation_errors' => array(
- *       array('step1'),       // Validate $form_state['values']['step1'].
- *       array('foo', 'bar'),  // Validate $form_state['values']['foo']['bar'].
- *     ),
- *     '#submit' => array('some_submit_function'), // #submit required.
- *   );
- * @endcode
- *
- * This will require $form_state['values']['step1'] and everything within it
- * (for example, $form_state['values']['step1']['choice']) to be valid, so
- * calls to form_set_error('step1', $message) or
- * form_set_error('step1][choice', $message) will prevent the submit handlers
- * from running, and result in the error message being displayed to the user.
- * However, calls to form_set_error('step2', $message) and
- * form_set_error('step2][groupX][choiceY', $message) will be suppressed,
- * resulting in the message not being displayed to the user, and the submit
- * handlers will run despite $form_state['values']['step2'] and
- * $form_state['values']['step2']['groupX']['choiceY'] containing invalid
- * values. Errors for an invalid $form_state['values']['foo'] will be
- * suppressed, but errors flagging invalid values for
- * $form_state['values']['foo']['bar'] and everything within it will be
- * flagged and submission prevented.
- *
- * Partial form validation is implemented by suppressing errors rather than by
- * skipping the input processing and validation steps entirely, because some
- * forms have button-level submit handlers that call Drupal API functions that
- * assume that certain data exists within $form_state['values'], and while not
- * doing anything with that data that requires it to be valid, PHP errors
- * would be triggered if the input processing and validation steps were fully
- * skipped.
- *
- * @param $name
- *   The name of the form element. If the #parents property of your form
- *   element is array('foo', 'bar', 'baz') then you may set an error on 'foo'
- *   or 'foo][bar][baz'. Setting an error on 'foo' sets an error for every
- *   element where the #parents array starts with 'foo'.
- * @param $message
- *   The error message to present to the user.
- * @param $limit_validation_errors
- *   Internal use only. The #limit_validation_errors property of the clicked
- *   button, if it exists.
- *
- * @return
- *   Return value is for internal use only. To get a list of errors, use
- *   form_get_errors() or form_get_error().
- *
- * @see http://drupal.org/node/370537
- * @see http://drupal.org/node/763376
+   * {@inheritdoc}
  */
-function form_set_error($name = NULL, $message = '', $limit_validation_errors = NULL) {
-  $form = &drupal_static(__FUNCTION__, array());
-  $sections = &drupal_static(__FUNCTION__ . ':limit_validation_errors');
+  public function setErrorByName($name = NULL, $message = '', $limit_validation_errors = NULL) {
   if (isset($limit_validation_errors)) {
-    $sections = $limit_validation_errors;
+      $this->errorSections = $limit_validation_errors;
   }
 
-  if (isset($name) && !isset($form[$name])) {
+    if (isset($name) && !isset($this->errors[$name])) {
     $record = TRUE;
-    if (isset($sections)) {
+      if (isset($this->errorSections)) {
       // #limit_validation_errors is an array of "sections" within which user
       // input must be valid. If the element is within one of these sections,
       // the error must be recorded. Otherwise, it can be suppressed.
@@ -1559,7 +1059,7 @@ function form_set_error($name = NULL, $m
       // submit action to be triggered even if none of the submitted values are
       // valid.
       $record = FALSE;
-      foreach ($sections as $section) {
+        foreach ($this->errorSections as $section) {
         // Exploding by '][' reconstructs the element's #parents. If the
         // reconstructed #parents begin with the same keys as the specified
         // section, then the element's values are within the part of
@@ -1574,41 +1074,38 @@ function form_set_error($name = NULL, $m
       }
     }
     if ($record) {
-      $form[$name] = $message;
+        $this->errors[$name] = $message;
       if ($message) {
-        drupal_set_message($message, 'error');
+          $this->drupalSetMessage($message, 'error');
       }
     }
   }
 
-  return $form;
+    return $this->errors;
 }
 
 /**
- * Clears all errors against all form elements made by form_set_error().
+   * {@inheritdoc}
  */
-function form_clear_error() {
-  drupal_static_reset('form_set_error');
+  public function clearErrors() {
+    $this->errors = array();
 }
 
 /**
- * Returns an associative array of all errors.
+   * {@inheritdoc}
  */
-function form_get_errors() {
-  $form = form_set_error();
+  public function getErrors() {
+    $form = $this->setErrorByName();
   if (!empty($form)) {
     return $form;
   }
 }
 
 /**
- * Returns the error message filed against the given form element.
- *
- * Form errors higher up in the form structure override deeper errors as well as
- * errors on the element itself.
+   * {@inheritdoc}
  */
-function form_get_error($element) {
-  $form = form_set_error();
+  public function getError($element) {
+    $form = $this->setErrorByName();
   $parents = array();
   foreach ($element['#parents'] as $parent) {
     $parents[] = $parent;
@@ -1620,109 +1117,21 @@ function form_get_error($element) {
 }
 
 /**
- * Flags an element as having an error.
+   * {@inheritdoc}
  */
-function form_error(&$element, $message = '') {
-  form_set_error(implode('][', $element['#parents']), $message);
+  public function setError(&$element, $message = '') {
+    $this->setErrorByName(implode('][', $element['#parents']), $message);
 }
 
 /**
- * Builds and processes all elements in the structured form array.
- *
- * Adds any required properties to each element, maps the incoming input data
- * to the proper elements, and executes any #process handlers attached to a
- * specific element.
- *
- * This is one of the three primary functions that recursively iterates a form
- * array. This one does it for completing the form building process. The other
- * two are _form_validate() (invoked via drupal_validate_form() and used to
- * invoke validation logic for each element) and drupal_render() (for rendering
- * each element). Each of these three pipelines provides ample opportunity for
- * modules to customize what happens. For example, during this function's life
- * cycle, the following functions get called for each element:
- * - $element['#value_callback']: A function that implements how user input is
- *   mapped to an element's #value property. This defaults to a function named
- *   'form_type_TYPE_value' where TYPE is $element['#type'].
- * - $element['#process']: An array of functions called after user input has
- *   been mapped to the element's #value property. These functions can be used
- *   to dynamically add child elements: for example, for the 'date' element
- *   type, one of the functions in this array is form_process_datetime(), which adds
- *   the individual 'date', and 'time'. child elements. These functions
- *   can also be used to set additional properties or implement special logic
- *   other than adding child elements: for example, for the 'details' element
- *   type, one of the functions in this array is form_process_details(), which
- *   adds the attributes and JavaScript needed to make the details work in older
- *   browsers. The #process functions are called in preorder traversal, meaning
- *   they are called for the parent element first, then for the child elements.
- * - $element['#after_build']: An array of callables called after form_builder()
- *   is done with its processing of the element. These are called in postorder
- *   traversal, meaning they are called for the child elements first, then for
- *   the parent element.
- * There are similar properties containing callback functions invoked by
- * _form_validate() and drupal_render(), appropriate for those operations.
- *
- * Developers are strongly encouraged to integrate the functionality needed by
- * their form or module within one of these three pipelines, using the
- * appropriate callback property, rather than implementing their own recursive
- * traversal of a form array. This facilitates proper integration between
- * multiple modules. For example, module developers are familiar with the
- * relative order in which hook_form_alter() implementations and #process
- * functions run. A custom traversal function that affects the building of a
- * form is likely to not integrate with hook_form_alter() and #process in the
- * expected way. Also, deep recursion within PHP is both slow and memory
- * intensive, so it is best to minimize how often it's done.
- *
- * As stated above, each element's #process functions are executed after its
- * #value has been set. This enables those functions to execute conditional
- * logic based on the current value. However, all of form_builder() runs before
- * drupal_validate_form() is called, so during #process function execution, the
- * element's #value has not yet been validated, so any code that requires
- * validated values must reside within a submit handler.
- *
- * As a security measure, user input is used for an element's #value only if the
- * element exists within $form, is not disabled (as per the #disabled property),
- * and can be accessed (as per the #access property, except that forms submitted
- * using drupal_form_submit() bypass #access restrictions). When user input is
- * ignored due to #disabled and #access restrictions, the element's default
- * value is used.
- *
- * Because of the preorder traversal, where #process functions of an element run
- * before user input for its child elements is processed, and because of the
- * Form API security of user input processing with respect to #access and
- * #disabled described above, this generally means that #process functions
- * should not use an element's (unvalidated) #value to affect the #disabled or
- * #access of child elements. Use-cases where a developer may be tempted to
- * implement such conditional logic usually fall into one of two categories:
- * - Where user input from the current submission must affect the structure of a
- *   form, including properties like #access and #disabled that affect how the
- *   next submission needs to be processed, a multi-step workflow is needed.
- *   This is most commonly implemented with a submit handler setting persistent
- *   data within $form_state based on *validated* values in
- *   $form_state['values'] and setting $form_state['rebuild']. The form building
- *   functions must then be implemented to use the $form_state data to rebuild
- *   the form with the structure appropriate for the new state.
- * - Where user input must affect the rendering of the form without affecting
- *   its structure, the necessary conditional rendering logic should reside
- *   within functions that run during the rendering phase (#pre_render, #theme,
- *   #theme_wrappers, and #post_render).
- *
- * @param $form_id
- *   A unique string identifying the form for validation, submission,
- *   theming, and hook_form_alter functions.
- * @param $element
- *   An associative array containing the structure of the current element.
- * @param $form_state
- *   A keyed array containing the current state of the form. In this
- *   context, it is used to accumulate information about which button
- *   was clicked when the form was submitted, as well as the sanitized
- *   $_POST data.
+   * {@inheritdoc}
  */
-function form_builder($form_id, &$element, &$form_state) {
+  public function doBuildForm($form_id, &$element, &$form_state) {
   // Initialize as unprocessed.
   $element['#processed'] = FALSE;
 
   // Use element defaults.
-  if (isset($element['#type']) && empty($element['#defaults_loaded']) && ($info = element_info($element['#type']))) {
+    if (isset($element['#type']) && empty($element['#defaults_loaded']) && ($info = $this->getElementInfo($element['#type']))) {
     // Overlay $info onto $element, retaining preexisting keys in $element.
     $element += $info;
     $element['#defaults_loaded'] = TRUE;
@@ -1750,7 +1159,7 @@ function form_builder($form_id, &$elemen
     $form_state['complete_form'] = &$element;
 
     // Set a flag if we have a correct form submission. This is always TRUE for
-    // programmed forms coming from drupal_form_submit(), or if the form_id coming
+      // programmed forms coming from self::submitForm(), or if the form_id coming
     // from the POST data is set and matches the current form_id.
     if ($form_state['programmed'] || (!empty($form_state['input']) && (isset($form_state['input']['form_id']) && ($form_state['input']['form_id'] == $form_id)))) {
       $form_state['process_input'] = TRUE;
@@ -1764,7 +1173,7 @@ function form_builder($form_id, &$elemen
   }
 
   if (!isset($element['#id'])) {
-    $element['#id'] = drupal_html_id('edit-' . implode('-', $element['#parents']));
+      $element['#id'] = $this->drupalHtmlId('edit-' . implode('-', $element['#parents']));
   }
 
   // Add the aria-describedby attribute to associate the form control with its
@@ -1774,7 +1183,7 @@ function form_builder($form_id, &$elemen
   }
   // Handle input elements.
   if (!empty($element['#input'])) {
-    _form_builder_handle_input_element($form_id, $element, $form_state);
+      $this->handleInputElement($form_id, $element, $form_state);
   }
   // Allow for elements to expand to multiple elements, e.g., radios,
   // checkboxes and files.
@@ -1790,10 +1199,10 @@ function form_builder($form_id, &$elemen
 
   // Recurse through all child elements.
   $count = 0;
-  foreach (element_children($element) as $key) {
+    foreach ($this->elementChildren($element) as $key) {
     // Prior to checking properties of child elements, their default properties
     // need to be loaded.
-    if (isset($element[$key]['#type']) && empty($element[$key]['#defaults_loaded']) && ($info = element_info($element[$key]['#type']))) {
+      if (isset($element[$key]['#type']) && empty($element[$key]['#defaults_loaded']) && ($info = $this->getElementInfo($element[$key]['#type']))) {
       $element[$key] += $info;
       $element[$key]['#defaults_loaded'] = TRUE;
     }
@@ -1836,7 +1245,7 @@ function form_builder($form_id, &$elemen
       // later.
       unset($element['#sorted']);
     }
-    $element[$key] = form_builder($form_id, $element[$key], $form_state);
+      $element[$key] = $this->doBuildForm($form_id, $element[$key], $form_state);
     $count++;
   }
 
@@ -1855,7 +1264,7 @@ function form_builder($form_id, &$elemen
     $form_state['has_file_element'] = TRUE;
   }
 
-  // Final tasks for the form element after form_builder() has run for all other
+    // Final tasks for the form element after self::doBuildForm() has run for all other
   // elements.
   if (isset($element['#type']) && $element['#type'] == 'form') {
     // If there is a file element, we set the form encoding.
@@ -1907,7 +1316,7 @@ function form_builder($form_id, &$elemen
 /**
  * Adds the #name and #value properties of an input element before rendering.
  */
-function _form_builder_handle_input_element($form_id, &$element, &$form_state) {
+  protected function handleInputElement($form_id, &$element, &$form_state) {
   if (!isset($element['#name'])) {
     $name = array_shift($element['#parents']);
     $element['#name'] = $name;
@@ -1929,7 +1338,7 @@ function _form_builder_handle_input_elem
   // is not wanted for the control. HTML supports two attributes for this:
   // http://www.w3.org/TR/html401/interact/forms.html#h-17.12. If a form wants
   // to start a control off with one of these attributes for UI purposes only,
-  // but still allow input to be processed if it's sumitted, it can set the
+    // but still allow input to be processed if it's submitted, it can set the
   // desired attribute in #attributes directly rather than using #disabled.
   // However, developers should think carefully about the accessibility
   // implications of doing so: if the form expects input to be enterable under
@@ -1953,9 +1362,9 @@ function _form_builder_handle_input_elem
   // elements with #access=FALSE or #disabled=TRUE. For security, these must
   // not be processed. Forms that set #disabled=TRUE on an element do not
   // expect input for the element, and even forms submitted with
-  // drupal_form_submit() must not be able to get around this. Forms that set
+    // self::submitForm() must not be able to get around this. Forms that set
   // #access=FALSE on an element usually allow access for some users, so forms
-  // submitted with drupal_form_submit() may bypass access restriction and be
+    // submitted with self::submitForm() may bypass access restriction and be
   // treated as high-privilege users instead.
   $process_input = empty($element['#disabled']) && ($form_state['programmed'] || ($form_state['process_input'] && (!isset($element['#access']) || $element['#access'])));
 
@@ -1974,7 +1383,7 @@ function _form_builder_handle_input_elem
       // distinguish elements having NULL input from elements that were not part
       // of the initially submitted form and can therefore use default values
       // for the latter, if required. Programmatically submitted forms can
-      // submit explicit NULL values when calling drupal_form_submit(), so we do
+        // submit explicit NULL values when calling self::submitForm(), so we do
       // not modify $form_state['input'] for them.
       if (!$input_exists && !$form_state['rebuild'] && !$form_state['programmed']) {
         // Add the necessary parent keys to $form_state['input'] and sets the
@@ -2018,7 +1427,7 @@ function _form_builder_handle_input_elem
   // as above.
   if ($process_input) {
     // Detect if the element triggered the submission via Ajax.
-    if (_form_element_triggered_scripted_submission($element, $form_state)) {
+      if ($this->elementTriggeredScriptedSubmission($element, $form_state)) {
       $form_state['triggering_element'] = $element;
     }
 
@@ -2027,10 +1436,10 @@ function _form_builder_handle_input_elem
     // button within the constraints of how browsers provide this information.
     if (!empty($element['#is_button'])) {
       // All buttons in the form need to be tracked for
-      // form_state_values_clean() and for the form_builder() code that handles
+        // form_state_values_clean() and for the self::doBuildForm() code that handles
       // a form submission containing no button information in $_POST.
       $form_state['buttons'][] = $element;
-      if (_form_button_was_clicked($element, $form_state)) {
+        if ($this->buttonWasClicked($element, $form_state)) {
         $form_state['triggering_element'] = $element;
       }
     }
@@ -2039,7 +1448,7 @@ function _form_builder_handle_input_elem
   // Set the element's value in $form_state['values'], but only, if its key
   // does not exist yet (a #value_callback may have already populated it).
   if (!NestedArray::keyExists($form_state['values'], $element['#parents'])) {
-    form_set_value($element, $element['#value'], $form_state);
+      $this->setValue($element, $element['#value'], $form_state);
   }
 }
 
@@ -2054,7 +1463,7 @@ function _form_builder_handle_input_elem
  * value. An example where this is needed is if there are several buttons all
  * named 'op', and only differing in their value.
  */
-function _form_element_triggered_scripted_submission($element, &$form_state) {
+  protected function elementTriggeredScriptedSubmission($element, &$form_state) {
   if (!empty($form_state['input']['_triggering_element_name']) && $element['#name'] == $form_state['input']['_triggering_element_name']) {
     if (empty($form_state['input']['_triggering_element_value']) || $form_state['input']['_triggering_element_value'] == $element['#value']) {
       return TRUE;
@@ -2073,9 +1482,9 @@ function _form_element_triggered_scripte
  * which browsers submit data for image button clicks.
  *
  * This does not detect button clicks processed by Ajax (that is done in
- * _form_element_triggered_scripted_submission()) and it does not detect form
+   * self::elementTriggeredScriptedSubmission()) and it does not detect form
  * submissions from Internet Explorer in response to an ENTER key pressed in a
- * textfield (form_builder() has extra code for that).
+   * textfield (self::doBuildForm() has extra code for that).
  *
  * Because this function contains only part of the logic needed to determine
  * $form_state['triggering_element'], it should not be called from anywhere
@@ -2083,7 +1492,7 @@ function _form_element_triggered_scripte
  * to know which button was clicked should get that information from
  * $form_state['triggering_element'].
  */
-function _form_button_was_clicked($element, &$form_state) {
+  protected function buttonWasClicked($element, &$form_state) {
   // First detect normal 'vanilla' button clicks. Traditionally, all
   // standard buttons on a form share the same name (usually 'op'),
   // and the specific return value is used to determine which was
@@ -2104,58 +1513,28 @@ function _form_button_was_clicked($eleme
 }
 
 /**
- * Changes submitted form values during form validation.
- *
- * Use this function to change the submitted value of a form element in a form
- * validation function, so that the changed value persists in $form_state
- * through to the submission handlers.
- *
- * Note that form validation functions are specified in the '#validate'
- * component of the form array (the value of $form['#validate'] is an array of
- * validation function names). If the form does not originate in your module,
- * you can implement hook_form_FORM_ID_alter() to add a validation function
- * to $form['#validate'].
- *
- * @param $element
- *   The form element that should have its value updated; in most cases you can
- *   just pass in the element from the $form array, although the only component
- *   that is actually used is '#parents'. If constructing yourself, set
- *   $element['#parents'] to be an array giving the path through the form
- *   array's keys to the element whose value you want to update. For instance,
- *   if you want to update the value of $form['elem1']['elem2'], which should be
- *   stored in $form_state['values']['elem1']['elem2'], you would set
- *   $element['#parents'] = array('elem1','elem2').
- * @param $value
- *   The new value for the form element.
- * @param $form_state
- *   Form state array where the value change should be recorded.
+   * {@inheritdoc}
  */
-function form_set_value($element, $value, &$form_state) {
+  public function setValue($element, $value, &$form_state) {
   NestedArray::setValue($form_state['values'], $element['#parents'], $value, TRUE);
 }
 
 /**
  * Triggers kernel.response and sends a form response.
  *
- * @deprecated This function is to be used internally by Form API only.
- *
  * @param \Symfony\Component\HttpFoundation\Response $response
  *   A response object.
  */
-function _drupal_form_send_response(Response $response) {
-  $request = \Drupal::request();
-  $kernel = \Drupal::service('http_kernel');
-  $event = new FilterResponseEvent($kernel, $request, $kernel::MASTER_REQUEST, $response);
+  protected function sendResponse(Response $response) {
+    $event = new FilterResponseEvent($this->httpKernel, $this->request, HttpKernelInterface::MASTER_REQUEST, $response);
 
-  \Drupal::service('event_dispatcher')->dispatch(KernelEvents::RESPONSE, $event);
+    $this->eventDispatcher->dispatch(KernelEvents::RESPONSE, $event);
   // Prepare and send the response.
   $event->getResponse()
-    ->prepare($request)
+      ->prepare($this->request)
     ->send();
-  $kernel->terminate($request, $response);
+    $this->httpKernel->terminate($this->request, $response);
   exit;
 }
 
-/**
- * @} End of "defgroup form_api".
- */
+}