Added overdraw visualization.

A common pattern here to make the code a little cleaner is to have initialize() return a boolean.
That way the code within the function reads better (`return false;` is failure as opposed to an implicit failure by returning and not setting `this.initialized = true;`), you get compile safety to make sure you are initializing properly (omitting a return at the end of the function is an error), and you can do the superclass initialize cleaner:
```
Subclass.prototype.initialize = function() {
  if (!goog.base(this, 'initialize')) {
    return false;
  }
  ....
  return true;
}
```

As for the initialized flag, you can actually move that out of the initialize pass and into the caller; for example, you use initialize() as an on-demand guard in a bunch of places instead of a one-time thing, so having a `prepare` or `ensureInitialized` function do the check makes it a little more clear to readers that is expects to be called more than once and lets you gracefully handle failure cases. Right now when your initialize fails it'll fail over and over and over and potentially kill the app/browser. You could throw this method on the superclass:
```
OffscreenSurface = function() {
  /** @private {boolean} */
  this.initialized_ = undefined;
};
OffscreenSurface.prototype.ensureInitialized = function() {
  // only the first time will we attempt to initialize - if it fails, then future calls will just return false.
  if (!goog.isDef(this.initialized_) {
    this.initialized_ = this.initialize();
  }
  return this.initialized_;
};
```