[Clocks/Timers] Update remaining classes

Complete code style changes for Clocks/Timers.

platform/features/clock/src/indicators/ClockIndicator.js

@@ -28,31 +28,39 @@ define(
 
         /**
          * Indicator that displays the current UTC time in the status area.
-         * @implements Indicator
+         * @implements {Indicator}
+         * @memberof platform/features/clock
+         * @param {platform/features/clock.TickerService} tickerService
+         *        a service used to align behavior with clock ticks
+         * @param {string} indicatorFormat format string for timestamps
+         *        shown in this indicator
          */
-        function ClockIndicator(tickerService, CLOCK_INDICATOR_FORMAT) {
+        function ClockIndicator(tickerService, indicatorFormat) {
-            var text = "";
+            var self = this;
+
+            this.text = "";
 
             tickerService.listen(function (timestamp) {
-                text = moment.utc(timestamp).format(CLOCK_INDICATOR_FORMAT) + " UTC";
+                self.text = moment.utc(timestamp)
+                    .format(indicatorFormat) + " UTC";
             });
-
-            return {
-                getGlyph: function () {
-                    return "C";
-                },
-                getGlyphClass: function () {
-                    return "";
-                },
-                getText: function () {
-                    return text;
-                },
-                getDescription: function () {
-                    return "";
         }
+
+        ClockIndicator.prototype.getGlyph = function () {
+            return "C";
         };
 
-        }
+        ClockIndicator.prototype.getGlyphClass = function () {
+            return "";
+        };
+
+        ClockIndicator.prototype.getText = function () {
+            return this.text;
+        };
+
+        ClockIndicator.prototype.getDescription = function () {
+            return "";
+        };
 
         return ClockIndicator;
     }

platform/features/clock/src/services/TickerService.js

@@ -30,23 +30,23 @@ define(
          * Calls functions every second, as close to the actual second
          * tick as is feasible.
          * @constructor
+         * @memberof platform/features/clock
          * @param $timeout Angular's $timeout
          * @param {Function} now function to provide the current time in ms
          */
         function TickerService($timeout, now) {
-            var callbacks = [],
+            var self = this;
-                last = now() - 1000;
 
             function tick() {
                 var timestamp = now(),
                     millis = timestamp % 1000;
 
                 // Only update callbacks if a second has actually passed.
-                if (timestamp >= last + 1000) {
+                if (timestamp >= self.last + 1000) {
-                    callbacks.forEach(function (callback) {
+                    self.callbacks.forEach(function (callback) {
                         callback(timestamp);
                     });
-                    last = timestamp - millis;
+                    self.last = timestamp - millis;
                 }
 
                 // Try to update at exactly the next second
@@ -55,35 +55,35 @@ define(
 
             tick();
 
-            return {
+            this.callbacks = [];
+            this.last = now() - 1000;
+        }
+
         /**
          * Listen for clock ticks. The provided callback will
          * be invoked with the current timestamp (in milliseconds
          * since Jan 1 1970) at regular intervals, as near to the
          * second boundary as possible.
          *
-                 * @method listen
-                 * @name TickerService#listen
          * @param {Function} callback callback to invoke
          * @returns {Function} a function to unregister this listener
          */
-                listen: function (callback) {
+        TickerService.prototype.listen = function (callback) {
-                    callbacks.push(callback);
+            var self = this;
+
+            self.callbacks.push(callback);
 
             // Provide immediate feedback
-                    callback(last);
+            callback(this.last);
 
             // Provide a deregistration function
             return function () {
-                        callbacks = callbacks.filter(function (cb) {
+                self.callbacks = self.callbacks.filter(function (cb) {
                     return cb !== callback;
                 });
             };
-                }
         };
 
-        }
-
         return TickerService;
     }
 );