view vendor/jcalderonzumba/gastonjs/src/Client/browser.js @ 9:1fc0ff908d1f

Add another data file

var __indexOf = [].indexOf || function (item) {
    for (var i = 0, l = this.length; i < l; i++) {
      if (i in this && this[i] === item) return i;
    }
    return -1;
  };

var xpathStringLiteral = function (s) {
  if (s.indexOf('"') === -1)
    return '"' + s + '"';
  if (s.indexOf("'") === -1)
    return "'" + s + "'";
  return 'concat("' + s.replace(/"/g, '",\'"\',"') + '")';
};

Poltergeist.Browser = (function () {
  /**
   * Creates the "browser" inside phantomjs
   * @param owner
   * @param width
   * @param height
   * @param jsErrors
   * @constructor
   */
  function Browser(owner, width, height, jsErrors) {
    this.owner = owner;
    this.width = width || 1024;
    this.height = height || 768;
    this.pages = [];
    this.js_errors = (typeof jsErrors === 'boolean') ? jsErrors : true;
    this._debug = false;
    this._counter = 0;
    this.resetPage();
  }

  /**
   * Resets the browser to a clean slate
   * @return {Function}
   */
  Browser.prototype.resetPage = function () {
    var _ref;
    var self = this;

    _ref = [0, []];
    this._counter = _ref[0];
    this.pages = _ref[1];

    if (this.page != null) {
      if (!this.page.closed) {
        if (this.page.currentUrl() !== 'about:blank') {
          this.page.clearLocalStorage();
        }
        this.page.release();
      }
      phantom.clearCookies();
    }

    this.page = this.currentPage = new Poltergeist.WebPage;
    this.page.setViewportSize({
      width: this.width,
      height: this.height
    });
    this.page.handle = "" + (this._counter++);
    this.pages.push(this.page);

    return this.page.onPageCreated = function (newPage) {
      var page;
      page = new Poltergeist.WebPage(newPage);
      page.handle = "" + (self._counter++);
      return self.pages.push(page);
    };
  };

  /**
   * Given a page handle id, tries to get it from the browser page list
   * @param handle
   * @return {WebPage}
   */
  Browser.prototype.getPageByHandle = function (handle) {
    var filteredPages;

    //TODO: perhaps we should throw a PageNotFoundByHandle or something like that..
    if (handle === null || typeof handle == "undefined") {
      return null;
    }

    filteredPages = this.pages.filter(function (p) {
      return !p.closed && p.handle === handle;
    });

    if (filteredPages.length === 1) {
      return filteredPages[0];
    }

    return null;
  };

  /**
   * Sends a debug message to the console
   * @param message
   * @return {*}
   */
  Browser.prototype.debug = function (message) {
    if (this._debug) {
      return console.log("poltergeist [" + (new Date().getTime()) + "] " + message);
    }
  };

  /**
   * Given a page_id and id, gets if possible the node in such page
   * @param page_id
   * @param id
   * @return {Poltergeist.Node}
   */
  Browser.prototype.node = function (page_id, id) {
    if (this.currentPage.id === page_id) {
      return this.currentPage.get(id);
    } else {
      throw new Poltergeist.ObsoleteNode;
    }
  };

  /**
   * Returns the frameUrl related to the frame given by name
   * @param frame_name
   * @return {*}
   */
  Browser.prototype.frameUrl = function (frame_name) {
    return this.currentPage.frameUrl(frame_name);
  };

  /**
   * This method defines the rectangular area of the web page to be rasterized when render is invoked.
   * If no clipping rectangle is set, render will process the entire web page.
   * @param full
   * @param selector
   * @return {*}
   */
  Browser.prototype.set_clip_rect = function (full, selector) {
    var dimensions, clipDocument, rect, clipViewport;

    dimensions = this.currentPage.validatedDimensions();
    clipDocument = dimensions.document;
    clipViewport = dimensions.viewport;

    if (full) {
      rect = {
        left: 0,
        top: 0,
        width: clipDocument.width,
        height: clipDocument.height
      };
    } else {
      if (selector != null) {
        rect = this.currentPage.elementBounds(selector);
      } else {
        rect = {
          left: 0,
          top: 0,
          width: clipViewport.width,
          height: clipViewport.height
        };
      }
    }

    this.currentPage.setClipRect(rect);
    return dimensions;
  };

  /**
   * Kill the browser, i.e kill phantomjs current process
   * @return {int}
   */
  Browser.prototype.exit = function () {
    return phantom.exit(0);
  };

  /**
   * Do nothing
   */
  Browser.prototype.noop = function () {
  };

  /**
   * Throws a new Object error
   */
  Browser.prototype.browser_error = function () {
    throw new Error('zomg');
  };

  /**
   *  Visits a page and load its content
   * @param serverResponse
   * @param url
   * @return {*}
   */
  Browser.prototype.visit = function (serverResponse, url) {
    var prevUrl;
    var self = this;
    this.currentPage.state = 'loading';
    prevUrl = this.currentPage.source === null ? 'about:blank' : this.currentPage.currentUrl();
    this.currentPage.open(url);
    if (/#/.test(url) && prevUrl.split('#')[0] === url.split('#')[0]) {
      this.currentPage.state = 'default';
      return this.serverSendResponse({
        status: 'success'
      }, serverResponse);
    } else {
      return this.currentPage.waitState('default', function () {
        if (self.currentPage.statusCode === null && self.currentPage.status === 'fail') {
          return self.owner.serverSendError(new Poltergeist.StatusFailError, serverResponse);
        } else {
          return self.serverSendResponse({
            status: self.currentPage.status
          }, serverResponse);
        }
      });
    }
  };

  /**
   *  Puts the control of the browser inside the IFRAME given by name
   * @param serverResponse
   * @param name
   * @param timeout
   * @return {*}
   */
  Browser.prototype.push_frame = function (serverResponse, name, timeout) {
    var _ref;
    var self = this;

    if (timeout == null) {
      timeout = new Date().getTime() + 2000;
    }

    //TODO: WTF, else if after a if with return COMMON
    if (_ref = this.frameUrl(name), __indexOf.call(this.currentPage.blockedUrls(), _ref) >= 0) {
      return this.serverSendResponse(true, serverResponse);
    } else if (this.currentPage.pushFrame(name)) {
      if (this.currentPage.currentUrl() === 'about:blank') {
        this.currentPage.state = 'awaiting_frame_load';
        return this.currentPage.waitState('default', function () {
          return self.serverSendResponse(true, serverResponse);
        });
      } else {
        return this.serverSendResponse(true, serverResponse);
      }
    } else {
      if (new Date().getTime() < timeout) {
        return setTimeout((function () {
          return self.push_frame(serverResponse, name, timeout);
        }), 50);
      } else {
        return this.owner.serverSendError(new Poltergeist.FrameNotFound(name), serverResponse);
      }
    }
  };

  /**
   *  Injects a javascript into the current page
   * @param serverResponse
   * @param extension
   * @return {*}
   */
  Browser.prototype.add_extension = function (serverResponse, extension) {
    //TODO: error control when the injection was not possible
    this.currentPage.injectExtension(extension);
    return this.serverSendResponse('success', serverResponse);
  };

  /**
   *  Returns the url we are currently in
   * @param serverResponse
   * @return {*}
   */
  Browser.prototype.current_url = function (serverResponse) {
    return this.serverSendResponse(this.currentPage.currentUrl(), serverResponse);
  };

  /**
   *  Returns the current page window name
   * @param serverResponse
   * @returns {*}
   */
  Browser.prototype.window_name = function (serverResponse) {
    return this.serverSendResponse(this.currentPage.windowName(), serverResponse);
  };

  /**
   *  Returns the status code associated to the page
   * @param serverResponse
   * @return {*}
   */
  Browser.prototype.status_code = function (serverResponse) {
    if (this.currentPage.statusCode === undefined || this.currentPage.statusCode === null) {
      return this.owner.serverSendError(new Poltergeist.StatusFailError("status_code_error"), serverResponse);
    }
    return this.serverSendResponse(this.currentPage.statusCode, serverResponse);
  };

  /**
   *  Returns the source code of the active frame, useful for when inside an IFRAME
   * @param serverResponse
   * @return {*}
   */
  Browser.prototype.body = function (serverResponse) {
    return this.serverSendResponse(this.currentPage.content(), serverResponse);
  };

  /**
   * Returns the source code of the page all the html
   * @param serverResponse
   * @return {*}
   */
  Browser.prototype.source = function (serverResponse) {
    return this.serverSendResponse(this.currentPage.source, serverResponse);
  };

  /**
   * Returns the current page title
   * @param serverResponse
   * @return {*}
   */
  Browser.prototype.title = function (serverResponse) {
    return this.serverSendResponse(this.currentPage.title(), serverResponse);
  };

  /**
   *  Finds the elements that match a method of selection and a selector
   * @param serverResponse
   * @param method
   * @param selector
   * @return {*}
   */
  Browser.prototype.find = function (serverResponse, method, selector) {
    return this.serverSendResponse({
      page_id: this.currentPage.id,
      ids: this.currentPage.find(method, selector)
    }, serverResponse);
  };

  /**
   * Find elements within a given element
   * @param serverResponse
   * @param page_id
   * @param id
   * @param method
   * @param selector
   * @return {*}
   */
  Browser.prototype.find_within = function (serverResponse, page_id, id, method, selector) {
    return this.serverSendResponse(this.node(page_id, id).find(method, selector), serverResponse);
  };

  /**
   * Returns ALL the text, visible and not visible from the given element
   * @param serverResponse
   * @param page_id
   * @param id
   * @return {*}
   */
  Browser.prototype.all_text = function (serverResponse, page_id, id) {
    return this.serverSendResponse(this.node(page_id, id).allText(), serverResponse);
  };

  /**
   * Returns the inner or outer html of a given id
   * @param serverResponse
   * @param page_id
   * @param id
   * @param type
   * @returns Object
   */
  Browser.prototype.all_html = function (serverResponse, page_id, id, type) {
    return this.serverSendResponse(this.node(page_id, id).allHTML(type), serverResponse);
  };

  /**
   *  Returns only the visible text in a given element
   * @param serverResponse
   * @param page_id
   * @param id
   * @return {*}
   */
  Browser.prototype.visible_text = function (serverResponse, page_id, id) {
    return this.serverSendResponse(this.node(page_id, id).visibleText(), serverResponse);
  };

  /**
   * Deletes the text in a given element leaving it empty
   * @param serverResponse
   * @param page_id
   * @param id
   * @return {*}
   */
  Browser.prototype.delete_text = function (serverResponse, page_id, id) {
    return this.serverSendResponse(this.node(page_id, id).deleteText(), serverResponse);
  };

  /**
   *  Gets the value of a given attribute in an element
   * @param serverResponse
   * @param page_id
   * @param id
   * @param name
   * @return {*}
   */
  Browser.prototype.attribute = function (serverResponse, page_id, id, name) {
    return this.serverSendResponse(this.node(page_id, id).getAttribute(name), serverResponse);
  };

  /**
   *  Allows the possibility to set an attribute on a given element
   * @param serverResponse
   * @param page_id
   * @param id
   * @param name
   * @param value
   * @returns {*}
   */
  Browser.prototype.set_attribute = function (serverResponse, page_id, id, name, value) {
    return this.serverSendResponse(this.node(page_id, id).setAttribute(name, value), serverResponse);
  };

  /**
   *  Allows the possibility to remove an attribute on a given element
   * @param serverResponse
   * @param page_id
   * @param id
   * @param name
   * @returns {*}
   */
  Browser.prototype.remove_attribute = function (serverResponse, page_id, id, name) {
    return this.serverSendResponse(this.node(page_id, id).removeAttribute(name), serverResponse);
  };

  /**
   * Returns all the attributes of a given element
   * @param serverResponse
   * @param page_id
   * @param id
   * @param name
   * @return {*}
   */
  Browser.prototype.attributes = function (serverResponse, page_id, id, name) {
    return this.serverSendResponse(this.node(page_id, id).getAttributes(), serverResponse);
  };

  /**
   *  Returns all the way to the document level the parents of a given element
   * @param serverResponse
   * @param page_id
   * @param id
   * @return {*}
   */
  Browser.prototype.parents = function (serverResponse, page_id, id) {
    return this.serverSendResponse(this.node(page_id, id).parentIds(), serverResponse);
  };

  /**
   * Returns the element.value of an element given by its page and id
   * @param serverResponse
   * @param page_id
   * @param id
   * @return {*}
   */
  Browser.prototype.value = function (serverResponse, page_id, id) {
    return this.serverSendResponse(this.node(page_id, id).value(), serverResponse);
  };

  /**
   *  Sets the element.value of an element by the given value
   * @param serverResponse
   * @param page_id
   * @param id
   * @param value
   * @return {*}
   */
  Browser.prototype.set = function (serverResponse, page_id, id, value) {
    this.node(page_id, id).set(value);
    return this.serverSendResponse(true, serverResponse);
  };

  /**
   *  Uploads a file to an input file element
   * @param serverResponse
   * @param page_id
   * @param id
   * @param file_path
   * @return {*}
   */
  Browser.prototype.select_file = function (serverResponse, page_id, id, file_path) {
    var node = this.node(page_id, id);

    this.currentPage.beforeUpload(node.id);
    this.currentPage.uploadFile('[_poltergeist_selected]', file_path);
    this.currentPage.afterUpload(node.id);

    return this.serverSendResponse(true, serverResponse);
  };

  /**
   * Sets a value to the selected element (to be used in select elements)
   * @param serverResponse
   * @param page_id
   * @param id
   * @param value
   * @return {*}
   */
  Browser.prototype.select = function (serverResponse, page_id, id, value) {
    return this.serverSendResponse(this.node(page_id, id).select(value), serverResponse);
  };

  /**
   *  Selects an option with the given value
   * @param serverResponse
   * @param page_id
   * @param id
   * @param value
   * @param multiple
   * @return {*}
   */
  Browser.prototype.select_option = function (serverResponse, page_id, id, value, multiple) {
    return this.serverSendResponse(this.node(page_id, id).select_option(value, multiple), serverResponse);
  };

  /**
   *
   * @param serverResponse
   * @param page_id
   * @param id
   * @return {*}
   */
  Browser.prototype.tag_name = function (serverResponse, page_id, id) {
    return this.serverSendResponse(this.node(page_id, id).tagName(), serverResponse);
  };


  /**
   * Tells if an element is visible or not
   * @param serverResponse
   * @param page_id
   * @param id
   * @return {*}
   */
  Browser.prototype.visible = function (serverResponse, page_id, id) {
    return this.serverSendResponse(this.node(page_id, id).isVisible(), serverResponse);
  };

  /**
   *  Tells if an element is disabled
   * @param serverResponse
   * @param page_id
   * @param id
   * @return {*}
   */
  Browser.prototype.disabled = function (serverResponse, page_id, id) {
    return this.serverSendResponse(this.node(page_id, id).isDisabled(), serverResponse);
  };

  /**
   *  Evaluates a javascript and returns the outcome to the client
   *  This will be JSON response so your script better be returning objects that can be used
   *  in JSON.stringify
   * @param serverResponse
   * @param script
   * @return {*}
   */
  Browser.prototype.evaluate = function (serverResponse, script) {
    return this.serverSendResponse(this.currentPage.evaluate("function() { return " + script + " }"), serverResponse);
  };

  /**
   *  Executes a javascript and goes back to the client with true if there were no errors
   * @param serverResponse
   * @param script
   * @return {*}
   */
  Browser.prototype.execute = function (serverResponse, script) {
    this.currentPage.execute("function() { " + script + " }");
    return this.serverSendResponse(true, serverResponse);
  };

  /**
   * If inside a frame then we will go back to the parent
   * Not defined behaviour if you pop and are not inside an iframe
   * @param serverResponse
   * @return {*}
   */
  Browser.prototype.pop_frame = function (serverResponse) {
    return this.serverSendResponse(this.currentPage.popFrame(), serverResponse);
  };

  /**
   * Gets the window handle id by a given window name
   * @param serverResponse
   * @param name
   * @return {*}
   */
  Browser.prototype.window_handle = function (serverResponse, name) {
    var handle, pageByWindowName;

    if (name === null || typeof name == "undefined" || name.length === 0) {
      return this.serverSendResponse(this.currentPage.handle, serverResponse);
    }

    handle = null;

    //Lets search the handle by the given window name
    var filteredPages = this.pages.filter(function (p) {
      return !p.closed && p.windowName() === name;
    });

    //A bit of error control is always good
    if (Array.isArray(filteredPages) && filteredPages.length >= 1) {
      pageByWindowName = filteredPages[0];
    } else {
      pageByWindowName = null;
    }

    if (pageByWindowName !== null && typeof pageByWindowName != "undefined") {
      handle = pageByWindowName.handle;
    }

    return this.serverSendResponse(handle, serverResponse);
  };

  /**
   * Returns all the window handles of opened windows
   * @param serverResponse
   * @return {*}
   */
  Browser.prototype.window_handles = function (serverResponse) {
    var handles, filteredPages;

    filteredPages = this.pages.filter(function (p) {
      return !p.closed;
    });

    if (filteredPages.length > 0) {
      handles = filteredPages.map(function (p) {
        return p.handle;
      });
      if (handles.length === 0) {
        handles = null;
      }
    } else {
      handles = null;
    }

    return this.serverSendResponse(handles, serverResponse);
  };

  /**
   *  Tries to switch to a window given by the handle id
   * @param serverResponse
   * @param handle
   * @return {*}
   */
  Browser.prototype.switch_to_window = function (serverResponse, handle) {
    var page;
    var self = this;

    page = this.getPageByHandle(handle);
    if (page === null || typeof page == "undefined") {
      throw new Poltergeist.NoSuchWindowError;
    }

    if (page !== this.currentPage) {
      return page.waitState('default', function () {
        self.currentPage = page;
        return self.serverSendResponse(true, serverResponse);
      });
    }

    return this.serverSendResponse(true, serverResponse);
  };

  /**
   * Opens a new window where we can do stuff
   * @param serverResponse
   * @return {*}
   */
  Browser.prototype.open_new_window = function (serverResponse) {
    return this.execute(serverResponse, 'window.open()');
  };

  /**
   * Closes the window given by handle name if possible
   * @param serverResponse
   * @param handle
   * @return {*}
   */
  Browser.prototype.close_window = function (serverResponse, handle) {
    var page;

    page = this.getPageByHandle(handle);
    if (page === null || typeof  page == "undefined") {
      //TODO: should we throw error since we actually could not find the window?
      return this.serverSendResponse(false, serverResponse);
    }

    //TODO: we have to add some control here to actually asses that the release has been done
    page.release();
    return this.serverSendResponse(true, serverResponse);
  };

  /**
   * Generic mouse event on an element
   * @param serverResponse
   * @param page_id
   * @param id
   * @param name
   * @return {number}
   */
  Browser.prototype.mouse_event = function (serverResponse, page_id, id, name) {
    var node;
    var self = this;
    node = this.node(page_id, id);
    this.currentPage.state = 'mouse_event';
    this.last_mouse_event = node.mouseEvent(name);
    return setTimeout(function () {
      if (self.currentPage.state === 'mouse_event') {
        self.currentPage.state = 'default';
        return self.serverSendResponse({
          position: self.last_mouse_event
        }, serverResponse);
      } else {
        return self.currentPage.waitState('default', function () {
          return self.serverSendResponse({
            position: self.last_mouse_event
          }, serverResponse);
        });
      }
    }, 5);
  };

  /**
   * Simple click on the element
   * @param serverResponse
   * @param page_id
   * @param id
   * @return {*}
   */
  Browser.prototype.click = function (serverResponse, page_id, id) {
    return this.mouse_event(serverResponse, page_id, id, 'click');
  };

  /**
   * Right click on the element
   * @param serverResponse
   * @param page_id
   * @param id
   * @return {*}
   */
  Browser.prototype.right_click = function (serverResponse, page_id, id) {
    return this.mouse_event(serverResponse, page_id, id, 'rightclick');
  };

  /**
   *  Double click on the element given by page and id
   * @param serverResponse
   * @param page_id
   * @param id
   * @return {*}
   */
  Browser.prototype.double_click = function (serverResponse, page_id, id) {
    return this.mouse_event(serverResponse, page_id, id, 'doubleclick');
  };

  /**
   * Executes a mousemove event on the page and given element
   * @param serverResponse
   * @param page_id
   * @param id
   * @return {*}
   */
  Browser.prototype.hover = function (serverResponse, page_id, id) {
    return this.mouse_event(serverResponse, page_id, id, 'mousemove');
  };

  /**
   * Triggers a mouse click event on the given coordinates
   * @param serverResponse
   * @param x
   * @param y
   * @return {*}
   */
  Browser.prototype.click_coordinates = function (serverResponse, x, y) {
    var response;

    this.currentPage.sendEvent('click', x, y);
    response = {
      click: {
        x: x,
        y: y
      }
    };

    return this.serverSendResponse(response, serverResponse);
  };

  /**
   *  Drags one element into another, useful for nice javascript thingies
   * @param serverResponse
   * @param page_id
   * @param id
   * @param other_id
   * @return {*}
   */
  Browser.prototype.drag = function (serverResponse, page_id, id, other_id) {
    this.node(page_id, id).dragTo(this.node(page_id, other_id));
    return this.serverSendResponse(true, serverResponse);
  };

  /**
   * Triggers an event on the given page and element
   * @param serverResponse
   * @param page_id
   * @param id
   * @param event
   * @return {*}
   */
  Browser.prototype.trigger = function (serverResponse, page_id, id, event) {
    this.node(page_id, id).trigger(event);
    return this.serverSendResponse(event, serverResponse);
  };

  /**
   * Checks if two elements are equal on a dom level
   * @param serverResponse
   * @param page_id
   * @param id
   * @param other_id
   * @return {*}
   */
  Browser.prototype.equals = function (serverResponse, page_id, id, other_id) {
    return this.serverSendResponse(this.node(page_id, id).isEqual(this.node(page_id, other_id)), serverResponse);
  };

  /**
   * Resets the current page to a clean slate
   * @param serverResponse
   * @return {*}
   */
  Browser.prototype.reset = function (serverResponse) {
    this.resetPage();
    return this.serverSendResponse(true, serverResponse);
  };

  /**
   * Scrolls to a position given by the left, top coordinates
   * @param serverResponse
   * @param left
   * @param top
   * @return {*}
   */
  Browser.prototype.scroll_to = function (serverResponse, left, top) {
    this.currentPage.setScrollPosition({
      left: left,
      top: top
    });
    return this.serverSendResponse(true, serverResponse);
  };

  /**
   * Sends keys to an element simulating as closest as possible what a user would do
   * when typing
   * @param serverResponse
   * @param page_id
   * @param id
   * @param keys
   * @return {*}
   */
  Browser.prototype.send_keys = function (serverResponse, page_id, id, keys) {
    var key, sequence, target, _i, _len;
    target = this.node(page_id, id);
    if (!target.containsSelection()) {
      target.mouseEvent('click');
    }
    for (_i = 0, _len = keys.length; _i < _len; _i++) {
      sequence = keys[_i];
      key = sequence.key != null ? this.currentPage.keyCode(sequence.key) : sequence;
      this.currentPage.sendEvent('keypress', key);
    }
    return this.serverSendResponse(true, serverResponse);
  };

  /**
   * Sends a native phantomjs key event to element
   * @param serverResponse
   * @param page_id
   * @param id
   * @param keyEvent
   * @param key
   * @param modifier
   */
  Browser.prototype.key_event = function (serverResponse, page_id, id, keyEvent, key, modifier) {
    var keyEventModifierMap;
    var keyEventModifier;
    var target;

    keyEventModifierMap = {
      'none': 0x0,
      'shift': 0x02000000,
      'ctrl': 0x04000000,
      'alt': 0x08000000,
      'meta': 0x10000000
    };
    keyEventModifier = keyEventModifierMap[modifier];

    target = this.node(page_id, id);
    if (!target.containsSelection()) {
      target.mouseEvent('click');
    }
    target.page.sendEvent(keyEvent, key, null, null, keyEventModifier);

    return this.serverSendResponse(true, serverResponse);
  };

  /**
   *  Sends the rendered page in a base64 encoding
   * @param serverResponse
   * @param format
   * @param full
   * @param selector
   * @return {*}
   */
  Browser.prototype.render_base64 = function (serverResponse, format, full, selector) {
    var encoded_image;
    if (selector == null) {
      selector = null;
    }
    this.set_clip_rect(full, selector);
    encoded_image = this.currentPage.renderBase64(format);
    return this.serverSendResponse(encoded_image, serverResponse);
  };

  /**
   * Renders the current page entirely or a given selection
   * @param serverResponse
   * @param path
   * @param full
   * @param selector
   * @return {*}
   */
  Browser.prototype.render = function (serverResponse, path, full, selector) {
    var dimensions;
    if (selector == null) {
      selector = null;
    }
    dimensions = this.set_clip_rect(full, selector);
    this.currentPage.setScrollPosition({
      left: 0,
      top: 0
    });
    this.currentPage.render(path);
    this.currentPage.setScrollPosition({
      left: dimensions.left,
      top: dimensions.top
    });
    return this.serverSendResponse(true, serverResponse);
  };


  /**
   * Sets the paper size, useful when printing to PDF
   * @param serverResponse
   * @param size
   * @return {*}
   */
  Browser.prototype.set_paper_size = function (serverResponse, size) {
    this.currentPage.setPaperSize(size);
    return this.serverSendResponse(true, serverResponse);
  };

  /**
   *  Sets the zoom factor on the current page
   * @param serverResponse
   * @param zoom_factor
   * @return {*}
   */
  Browser.prototype.set_zoom_factor = function (serverResponse, zoom_factor) {
    this.currentPage.setZoomFactor(zoom_factor);
    return this.serverSendResponse(true, serverResponse);
  };

  /**
   * Resizes the browser viewport, useful when testing mobile stuff
   * @param serverResponse
   * @param width
   * @param height
   * @return {*}
   */
  Browser.prototype.resize = function (serverResponse, width, height) {
    this.currentPage.setViewportSize({
      width: width,
      height: height
    });
    return this.serverSendResponse(true, serverResponse);
  };

  /**
   * Gets the browser viewport size
   * Because PhantomJS is headless (nothing is shown)
   * viewportSize effectively simulates the size of the window like in a traditional browser.
   * @param serverResponse
   * @param handle
   * @return {*}
   */
  Browser.prototype.window_size = function (serverResponse, handle) {
    //TODO: add support for window handles
    return this.serverSendResponse(this.currentPage.viewportSize(), serverResponse);
  };

  /**
   * Returns the network traffic that the current page has generated
   * @param serverResponse
   * @return {*}
   */
  Browser.prototype.network_traffic = function (serverResponse) {
    return this.serverSendResponse(this.currentPage.networkTraffic(), serverResponse);
  };

  /**
   * Clears the accumulated network_traffic in the current page
   * @param serverResponse
   * @return {*}
   */
  Browser.prototype.clear_network_traffic = function (serverResponse) {
    this.currentPage.clearNetworkTraffic();
    return this.serverSendResponse(true, serverResponse);
  };

  /**
   * Gets the headers of the current page
   * @param serverResponse
   * @return {*}
   */
  Browser.prototype.get_headers = function (serverResponse) {
    return this.serverSendResponse(this.currentPage.getCustomHeaders(), serverResponse);
  };

  /**
   * Set headers in the browser
   * @param serverResponse
   * @param headers
   * @return {*}
   */
  Browser.prototype.set_headers = function (serverResponse, headers) {
    if (headers['User-Agent']) {
      this.currentPage.setUserAgent(headers['User-Agent']);
    }
    this.currentPage.setCustomHeaders(headers);
    return this.serverSendResponse(true, serverResponse);
  };

  /**
   * Given an array of headers, adds them to the page
   * @param serverResponse
   * @param headers
   * @return {*}
   */
  Browser.prototype.add_headers = function (serverResponse, headers) {
    var allHeaders, name, value;
    allHeaders = this.currentPage.getCustomHeaders();
    for (name in headers) {
      if (headers.hasOwnProperty(name)) {
        value = headers[name];
        allHeaders[name] = value;
      }
    }
    return this.set_headers(serverResponse, allHeaders);
  };

  /**
   * Adds a header to the page temporary or permanently
   * @param serverResponse
   * @param header
   * @param permanent
   * @return {*}
   */
  Browser.prototype.add_header = function (serverResponse, header, permanent) {
    if (!permanent) {
      this.currentPage.addTempHeader(header);
    }
    return this.add_headers(serverResponse, header);
  };


  /**
   * Sends back the client the response headers sent from the browser when making
   * the page request
   * @param serverResponse
   * @return {*}
   */
  Browser.prototype.response_headers = function (serverResponse) {
    return this.serverSendResponse(this.currentPage.responseHeaders(), serverResponse);
  };

  /**
   * Returns the cookies of the current page being browsed
   * @param serverResponse
   * @return {*}
   */
  Browser.prototype.cookies = function (serverResponse) {
    return this.serverSendResponse(this.currentPage.cookies(), serverResponse);
  };

  /**
   * Sets a cookie in the browser, the format of the cookies has to be the format it says
   * on phantomjs documentation and as such you can set it in other domains, not on the
   * current page
   * @param serverResponse
   * @param cookie
   * @return {*}
   */
  Browser.prototype.set_cookie = function (serverResponse, cookie) {
    return this.serverSendResponse(phantom.addCookie(cookie), serverResponse);
  };

  /**
   * Remove a cookie set on the current page
   * @param serverResponse
   * @param name
   * @return {*}
   */
  Browser.prototype.remove_cookie = function (serverResponse, name) {
    //TODO: add error control to check if the cookie was properly deleted
    this.currentPage.deleteCookie(name);
    phantom.deleteCookie(name);
    return this.serverSendResponse(true, serverResponse);
  };

  /**
   * Clear the cookies in the browser
   * @param serverResponse
   * @return {*}
   */
  Browser.prototype.clear_cookies = function (serverResponse) {
    phantom.clearCookies();
    return this.serverSendResponse(true, serverResponse);
  };

  /**
   * Enables / Disables the cookies on the browser
   * @param serverResponse
   * @param flag
   * @return {*}
   */
  Browser.prototype.cookies_enabled = function (serverResponse, flag) {
    phantom.cookiesEnabled = flag;
    return this.serverSendResponse(true, serverResponse);
  };

  /**
   * US19: DONE
   * Sets a basic authentication credential to access a page
   * THIS SHOULD BE USED BEFORE accessing a page
   * @param serverResponse
   * @param user
   * @param password
   * @return {*}
   */
  Browser.prototype.set_http_auth = function (serverResponse, user, password) {
    this.currentPage.setHttpAuth(user, password);
    return this.serverSendResponse(true, serverResponse);
  };

  /**
   * Sets the flag whether to fail on javascript errors or not.
   * @param serverResponse
   * @param value
   * @return {*}
   */
  Browser.prototype.set_js_errors = function (serverResponse, value) {
    this.js_errors = value;
    return this.serverSendResponse(true, serverResponse);
  };

  /**
   * Sets the debug mode to boolean value
   * @param serverResponse
   * @param value
   * @return {*}
   */
  Browser.prototype.set_debug = function (serverResponse, value) {
    this._debug = value;
    return this.serverSendResponse(true, serverResponse);
  };

  /**
   * Goes back in the history when possible
   * @param serverResponse
   * @return {*}
   */
  Browser.prototype.go_back = function (serverResponse) {
    var self = this;
    if (this.currentPage.canGoBack()) {
      this.currentPage.state = 'loading';
      this.currentPage.goBack();
      return this.currentPage.waitState('default', function () {
        return self.serverSendResponse(true, serverResponse);
      });
    } else {
      return this.serverSendResponse(false, serverResponse);
    }
  };

  /**
   * Reloads the page if possible
   * @return {*}
   */
  Browser.prototype.reload = function (serverResponse) {
    var self = this;
    this.currentPage.state = 'loading';
    this.currentPage.reload();
    return this.currentPage.waitState('default', function () {
      return self.serverSendResponse(true, serverResponse);
    });
  };

  /**
   * Goes forward in the browser history if possible
   * @param serverResponse
   * @return {*}
   */
  Browser.prototype.go_forward = function (serverResponse) {
    var self = this;
    if (this.currentPage.canGoForward()) {
      this.currentPage.state = 'loading';
      this.currentPage.goForward();
      return this.currentPage.waitState('default', function () {
        return self.serverSendResponse(true, serverResponse);
      });
    } else {
      return this.serverSendResponse(false, serverResponse);
    }
  };

  /**
   *  Sets the urlBlacklist for the given urls as parameters
   * @return {boolean}
   */
  Browser.prototype.set_url_blacklist = function (serverResponse, blackList) {
    this.currentPage.urlBlacklist = Array.prototype.slice.call(blackList);
    return this.serverSendResponse(true, serverResponse);
  };

  /**
   * Runs a browser command and returns the response back to the client
   * when the command has finished the execution
   * @param command
   * @param serverResponse
   * @return {*}
   */
  Browser.prototype.serverRunCommand = function (command, serverResponse) {
    var commandData;
    var commandArgs;
    var commandName;

    commandName = command.name;
    commandArgs = command.args;
    this.currentPage.state = 'default';
    commandData = [serverResponse].concat(commandArgs);

    if (typeof this[commandName] !== "function") {
      //We can not run such command
      throw new Poltergeist.Error();
    }

    return this[commandName].apply(this, commandData);
  };

  /**
   * Sends a response back to the client who made the request
   * @param response
   * @param serverResponse
   * @return {*}
   */
  Browser.prototype.serverSendResponse = function (response, serverResponse) {
    var errors;
    errors = this.currentPage.errors;
    this.currentPage.clearErrors();
    if (errors.length > 0 && this.js_errors) {
      return this.owner.serverSendError(new Poltergeist.JavascriptError(errors), serverResponse);
    } else {
      return this.owner.serverSendResponse(response, serverResponse);
    }
  };

  return Browser;

})();