chrome/browser/resources/chromeos/login/oobe-screen.js

   1 // Copyright (c) 2014 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 Polymer('oobe-screen', (function() {
   6   /** @const */ var CALLBACK_USER_ACTED = 'userActed';
   7
   8   function doNothing() {};
   9
  10   return {
  11     /**
  12      * The login.Screen which is hosting |this|.
  13      */
  14     screen_: null,
  15
  16     /**
  17      * Dictionary of context observers that are methods of |this| bound to
  18      * |this|.
  19      */
  20     contextObservers_: null,
  21
  22     /**
  23      * login.ScreenContext used for sharing data with native backend.
  24      */
  25     context: null,
  26
  27     /**
  28      * Internal storage of |this.context|. Short name has been choosen for
  29      * reason: such name doesn't take much space in HTML data bindings, which
  30      * are used very often.
  31      * C binded to the native part of the context, that means that all the
  32      * changes in the native part appear in C automatically. Reverse is not
  33      * true, you should use:
  34      *    this.context.set(...);
  35      *    this.context.commitContextChanges();
  36      * to send updates to the native part.
  37      * TODO(dzhioev): make binding two-way.
  38      */
  39     C: null,
  40
  41     /**
  42      * Called when the screen is being registered.
  43      */
  44     initialize: doNothing,
  45
  46     ready: function() {
  47       if (this.decorate_) {
  48         this.initialize();
  49       } else {
  50         this.ready_ = true;
  51       }
  52     },
  53
  54     userActed: function(_, _, source) {
  55       this.send(CALLBACK_USER_ACTED, source.getAttribute('action'));
  56     },
  57
  58     i18n: function(args) {
  59       if (!(args instanceof Array))
  60         args = [args];
  61       args[0] = 'login_' + this.name + '_' + args[0];
  62       return loadTimeData.getStringF.apply(loadTimeData, args);
  63     },
  64
  65     /**
  66      * Called by login.Screen when the screen is beeing registered.
  67      */
  68     decorate: function(screen) {
  69       this.screen_ = screen;
  70       this.context = screen.screenContext_;
  71       this.C = this.context.storage_;
  72       this.contextObservers_ = {};
  73       var self = this;
  74       if (this.ready_) {
  75         this.initialize();
  76       } else {
  77         this.decorate_ = true;
  78       }
  79     },
  80
  81     /**
  82      * @final
  83      */
  84     send: function() {
  85       return this.sendImpl_.apply(this, arguments);
  86     },
  87
  88     /**
  89      * @final
  90      */
  91     addContextObserver: function() {
  92       return this.addContextObserverImpl_.apply(this, arguments);
  93     },
  94
  95     /**
  96      * @final
  97      */
  98     removeContextObserver: function() {
  99       return this.removeContextObserverImpl_.apply(this, arguments);
 100     },
 101
 102     /**
 103      * @final
 104      */
 105     commitContextChanges: function() {
 106       return this.commitContextChangesImpl_.apply(this, arguments);
 107     },
 108
 109     /**
 110      * @override
 111      * @final
 112      */
 113     querySelector: function() {
 114       return this.querySelectorImpl_.apply(this, arguments);
 115     },
 116
 117     /**
 118      * @override
 119      * @final
 120      */
 121     querySelectorAll: function() {
 122       return this.querySelectorAllImpl_.apply(this, arguments);
 123     },
 124
 125     /**
 126      * See login.Screen.send.
 127      * @private
 128      */
 129     sendImpl_: function() {
 130       return this.screen_.send.apply(this.screen_, arguments);
 131     },
 132
 133     /**
 134      * Starts observation of property with |key| of the context attached to
 135      * current screen. This method differs from "login.ScreenContext" in that
 136      * it automatically detects if observer is method of |this| and make
 137      * all needed actions to make it work correctly. So it's no need for client
 138      * to bind methods to |this| and keep resulting callback for
 139      * |removeObserver| call:
 140      *
 141      *   this.addContextObserver('key', this.onKeyChanged_);
 142      *   ...
 143      *   this.removeContextObserver('key', this.onKeyChanged_);
 144      * @private
 145      */
 146     addContextObserverImpl_: function(key, observer) {
 147       var realObserver = observer;
 148       var propertyName = this.getPropertyNameOf_(observer);
 149       if (propertyName) {
 150         if (!this.contextObservers_.hasOwnProperty(propertyName))
 151           this.contextObservers_[propertyName] = observer.bind(this);
 152         realObserver = this.contextObservers_[propertyName];
 153       }
 154       this.context.addObserver(key, realObserver);
 155     },
 156
 157     /**
 158      * Removes |observer| from the list of context observers. Supports not only
 159      * regular functions but also screen methods (see comment to
 160      * |addContextObserver|).
 161      * @private
 162      */
 163     removeContextObserverImpl_: function(observer) {
 164       var realObserver = observer;
 165       var propertyName = this.getPropertyNameOf_(observer);
 166       if (propertyName) {
 167         if (!this.contextObservers_.hasOwnProperty(propertyName))
 168           return;
 169         realObserver = this.contextObservers_[propertyName];
 170         delete this.contextObservers_[propertyName];
 171       }
 172       this.context.removeObserver(realObserver);
 173     },
 174
 175     /**
 176      * See login.Screen.commitContextChanges.
 177      * @private
 178      */
 179     commitContextChangesImpl_: function() {
 180       return this.screen_.commitContextChanges.apply(this.screen_, arguments);
 181     },
 182
 183     /**
 184      * Calls |querySelector| method of the shadow dom and returns the result.
 185      * @private
 186      */
 187     querySelectorImpl_: function(selector) {
 188       return this.shadowRoot.querySelector(selector);
 189     },
 190
 191
 192     /**
 193      * Calls standart |querySelectorAll| method of the shadow dom and returns
 194      * the result converted to Array.
 195      * @private
 196      */
 197     querySelectorAllImpl_: function(selector) {
 198       var list = this.shadowRoot.querySelectorAll(selector);
 199       return Array.prototype.slice.call(list);
 200     },
 201
 202     /**
 203      * If |value| is the value of some property of |this| returns property's
 204      * name. Otherwise returns empty string.
 205      * @private
 206      */
 207     getPropertyNameOf_: function(value) {
 208       for (var key in this)
 209         if (this[key] === value)
 210           return key;
 211       return '';
 212     }
 213   };
 214 })());
 215