net.BrowserChannel Extends
Encapsulates the logic for a single BrowserChannel.

Inheritance

Constructor

goog.net.BrowserChannel(opt_clientVersionopt_firstTestResultsopt_secondTestResults)

Parameters

opt_clientVersion : string=
An application-specific version number that is sent to the server when connected.
opt_firstTestResults : Array.<string>>
Previously determined results of the first browser channel test.
opt_secondTestResults : boolean=
Previously determined results of the second browser channel test.

Instance Methods

Public Protected Private
addAdditionalParams_(uri)
Adds the additional parameters from the handler to the given URI.
Arguments:
uri : goog.Uri
The URI to add the parameters to.
code »
cancelRequests_()
Cancels all outstanding requests.
code »
clearDeadBackchannelTimer_()
Clears the timer that indicates that our backchannel is no longer able to successfully receive data from the server.
code »
connect(testPathchannelPathopt_extraParamsopt_oldSessionIdopt_oldArrayId)
Starts the channel. This initiates connections to the server.
Arguments:
testPath : string
The path for the test connection.
channelPath : string
The path for the channel connection.
opt_extraParams : Object=
Extra parameter keys and values to add to the requests.
opt_oldSessionId : string=
Session ID from a previous session.
opt_oldArrayId : number=
The last array ID from a previous session.
code »
connectChannel_()
Starts the regular channel which is run after the test channel is complete.
code »
connectTest_(testPath)
Starts the test channel to determine network conditions.
Arguments:
testPath : string
The relative PATH for the test connection.
code »
correctHostPrefix(serverHostPrefix) ?string
Decides which host prefix should be used, if any. If there is a handler, allows the handler to validate a host prefix provided by the server, and optionally override it.
Arguments:
serverHostPrefix : ?string
The host prefix provided by the server.
Returns: ?string  The host prefix to actually use, if any. Will return null if the use of host prefixes was disabled via setAllowHostPrefix().
code »
createDataUri(hostPrefixpathopt_overridePort) !goog.Uri
Creates a data Uri applying logic for secondary hostprefix, port overrides, and versioning.
Arguments:
hostPrefix : ?string
The host prefix.
path : string
The path on the host (may be absolute or relative).
opt_overridePort : number=
Optional override port.
Returns: !goog.Uri  The data URI.
code »
createXhrIo(hostPrefix) !goog.net.XhrIo
Called when BC needs to create an XhrIo object. Override in a subclass if you need to customize the behavior, for example to enable the creation of XHR's capable of calling a secondary domain. Will also allow calling a secondary domain if withCredentials (CORS) is enabled.
Arguments:
hostPrefix : ?string
The host prefix, if we need an XhrIo object capable of calling a secondary domain.
Returns: !goog.net.XhrIo  A new XhrIo object.
code »
dequeueOutgoingMaps_() string
Returns the request text from the outgoing maps and resets it.
Returns: string  The encoded request text created from all the currently queued outgoing maps.
code »
disconnect()
Disconnects and closes the channel.
code »
ensureBackChannel_()
Ensures there is a backchannel request for receiving data from the server.
code »
ensureForwardChannel_()
Ensures that a forward channel request is scheduled.
code »
ensureInState_(var_args)
Helper to ensure the BrowserChannel is in the expected state.
Arguments:
var_args : ...number
The channel must be in one of the indicated states.
code »
getAllowChunkedMode()
Returns whether chunked mode is allowed. In certain debugging situations, it's useful for the application to have a way to disable chunked mode for a user. @return {boolean} Whether chunked mode is allowed.
code »
getAllowHostPrefix() boolean
Returns whether the channel allows the use of a subdomain. There may be cases where this isn't allowed.
Returns: boolean  Whether a host prefix is allowed.
code »
getBackChannelMaxRetries() number
No description.
Returns: number  The max number of back-channel retries, which is a constant.
code »
getBackChannelUri(hostPrefixpath) !goog.Uri
Gets the Uri used for the connection that receives data from the server.
Arguments:
hostPrefix : ?string
The host prefix.
path : string
The path on the host.
Returns: !goog.Uri  The back channel URI.
code »
getChannelDebug() !goog.net.ChannelDebug
Returns the browserchannel logger.
Returns: !goog.net.ChannelDebug  The channel debug object.
code »
getExtraHeaders() Object
Returns the extra HTTP headers to add to all the requests sent to the server.
Returns: Object  The HTTP headers, or null.
code »
getFirstTestResults() Array.<string>
Gets the results for the first browser channel test
Returns: Array.<string>  The results.
code »
getForwardChannelMaxRetries() number
No description.
Returns: number  The max number of forward-channel retries, which will be 0 in fail-fast mode.
code »
getForwardChannelUri(path) !goog.Uri
Gets the Uri used for the connection that sends data to the server.
Arguments:
path : string
The path on the host.
Returns: !goog.Uri  The forward channel URI.
code »
Returns the handler used for channel callback events.
Returns: goog.net.BrowserChannel.Handler  The handler.
code »
getLastArrayId() number
No description.
Returns: number  The last array id received.
code »
getLastStatusCode() number
Return the last status code received for a request.
Returns: number  The last status code received for a request.
code »
getRetryTime_(retryCount) number
No description.
Arguments:
retryCount : number
Number of retries so far.
Returns: number  Time in ms before firing next retry request.
code »
getSecondTestResults() ?boolean
Gets the results for the second browser channel test
Returns: ?boolean  The results. True -> buffered connection, False -> unbuffered, null -> unknown.
code »
getSessionId() string
Returns the session id of the channel. Only available after the channel has been opened.
Returns: string  Session ID.
code »
getState() goog.net.BrowserChannel.State
Returns the browser channel state.
Returns: goog.net.BrowserChannel.State  The current state of the browser channel.
code »
handleBackchannelMissing_()
Handles a POST response from the server telling us that it has detected that we have no hanging GET connection.
code »
handlePostResponse_(responseValues)
Handles a POST response from the server.
Arguments:
responseValues : Array
The key value pairs in the POST response.
code »
hasOutstandingRequests() boolean
Returns whether there are outstanding requests servicing the channel.
Returns: boolean  true if there are outstanding requests.
code »
isActive() boolean
Gets whether this channel is currently active. This is used to determine the length of time to wait before retrying. This call delegates to the handler.
Returns: boolean  Whether the channel is currently active.
code »
isBuffered() boolean
Returns whether the channel is buffered or not. This state is valid for querying only after the test connection has completed. This may be queried in the goog.net.BrowserChannel.okToMakeRequest() callback. A channel may be buffered if the test connection determines that a chunked response could not be sent down within a suitable time.
Returns: boolean  Whether the channel is buffered.
code »
isClosed() boolean
Returns whether the channel is closed
Returns: boolean  true if the channel is closed.
code »
makeForwardChannelRequest_(opt_retryRequest)
Makes a forward channel request using XMLHTTP.
Arguments:
opt_retryRequest : goog.net.ChannelRequest=
A failed request to retry.
code »
maybeRetryBackChannel_() boolean
Schedules a back-channel retry, unless the max retries has been reached.
Returns: boolean  true iff a retry was scheduled.
code »
maybeRetryForwardChannel_(request) boolean
Schedules a forward-channel retry for the specified request, unless the max retries has been reached.
Arguments:
request : goog.net.ChannelRequest
The failed request to retry.
Returns: boolean  true iff a retry was scheduled.
code »
notifyServerReachabilityEvent(reachabilityType)
Notify the channel that a particular fine grained network event has occurred. Should be considered package-private.
Arguments:
reachabilityType : goog.net.BrowserChannel.ServerReachability
The reachability event type.
code »
okToMakeRequest_() boolean
Gives the handler a chance to return an error code and stop channel execution. A handler might want to do this to check that the user is still logged in, for example.
Returns: boolean  If it's OK to make a request.
code »
onBackChannelDead_()
Handles the timer that indicates that our backchannel is no longer able to successfully receive data from the server.
code »
onClose_()
Called when the channel has been closed. It notifiers the handler of the event, and reports any pending or undelivered maps.
code »
onError_(error)
Called when we've determined the final error for a channel. It closes the notifiers the handler of the error and closes the channel.
Arguments:
error : goog.net.BrowserChannel.Error
The error code for the failure.
code »
onInput_(respArray)
Processes the data returned by the server.
Arguments:
respArray : !Array.<!Array>
The response array returned by the server.
code »
onRequestComplete(request)
Callback from ChannelRequest that indicates a request has completed.
Arguments:
request : goog.net.ChannelRequest
The request object.
code »
onRequestData(requestresponseText)
Callback from ChannelRequest for when new data is received
Arguments:
request : goog.net.ChannelRequest
The request object.
responseText : string
The text of the response.
code »
onStartBackChannelTimer_()
Timer callback for ensureBackChannel_.
code »
onStartForwardChannelTimer_(opt_retryRequest)
Timer callback for ensureForwardChannel
Arguments:
opt_retryRequest : goog.net.ChannelRequest=
A failed request to retry.
code »
onSuccess_()
Called when messages have been successfully sent from the queue.
code »
open_()
Establishes a new channel session with the the server.
code »
outstandingRequests_() number
Returns the number of outstanding requests.
Returns: number  The number of outstanding requests to the server.
code »
requeuePendingMaps_()
Requeues unacknowledged sent arrays for retransmission in the next forward channel request.
code »
sendMap(mapopt_context)
Sends a request to the server. The format of the request is a Map data structure of key/value pairs. These maps are then encoded in a format suitable for the wire and then reconstituted as a Map data structure that the server can process.
Arguments:
map : Object | goog.structs.Map
The map to send.
opt_context : ?Object=
The context associated with the map.
code »
setAllowChunkedMode(allowChunkedMode)
Sets whether chunked mode is allowed. In certain debugging situations, it's useful for the application to have a way to disable chunked mode for a user.
Arguments:
allowChunkedMode : boolean
Whether chunked mode is allowed.
code »
setAllowHostPrefix(allowHostPrefix)
Sets whether the channel allows the use of a subdomain. There may be cases where this isn't allowed, for example, logging in with troutboard where using a subdomain causes Apache to force the user to authenticate twice.
Arguments:
allowHostPrefix : boolean
Whether a host prefix is allowed.
code »
setChannelDebug(channelDebug)
Set the browserchannel logger. TODO(user): Add interface for channel loggers or remove this function.
Arguments:
channelDebug : goog.net.ChannelDebug
The channel debug object.
code »
setExtraHeaders(extraHeaders)
Sets extra HTTP headers to add to all the requests sent to the server.
Arguments:
extraHeaders : Object
The HTTP headers, or null.
code »
setFailFast(failFast)
When set to true, this changes the behavior of the forward channel so it will not retry requests; it will fail after one network failure, and if there was already one network failure, the request will fail immediately.
Arguments:
failFast : boolean
Whether or not to fail fast.
code »
setForwardChannelMaxRetries(retries)
Sets the maximum number of attempts to connect to the server for forward channel requests.
Arguments:
retries : number
The maximum number of attempts.
code »
setForwardChannelRequestTimeout(timeoutMs)
Sets the timeout for a forward channel request.
Arguments:
timeoutMs : number
The timeout in milliseconds.
code »
setHandler(handler)
Sets the handler used for channel callback events.
Arguments:
handler : goog.net.BrowserChannel.Handler
The handler to set.
code »
setParser(parser)
Sets a new parser for the response payload. A custom parser may be set to avoid using eval(), for example. By default, the parser uses goog.json.unsafeParse.
Arguments:
parser : !goog.string.Parser
Parser.
code »
setReadyStateChangeThrottle(throttle)
Sets the throttle for handling onreadystatechange events for the request.
Arguments:
throttle : number
The throttle in ms. A value of zero indicates no throttle.
code »
setRetryDelay(baseDelayMsdelaySeedMs)
No description.
Arguments:
baseDelayMs : number
The base part of the retry delay, in ms.
delaySeedMs : number
A random delay between 0 and this is added to the base part.
code »
setSupportsCrossDomainXhrs(supportCrossDomain)
Sets whether cross origin requests are supported for the browser channel. Setting this allows the creation of requests to secondary domains and sends XHRs with the CORS withCredentials bit set to true. In order for cross-origin requests to work, the server will also need to set CORS response headers as per: https://developer.mozilla.org/en-US/docs/HTTP_access_control See goog.net.XhrIo#setWithCredentials.
Arguments:
supportCrossDomain : boolean
Whether cross domain XHRs are supported.
code »
shouldRetryBackChannel_(outstandingBytes) boolean
Determines whether we should start the process of retrying a possibly dead backchannel.
Arguments:
outstandingBytes : number
The number of bytes for which the server has not yet received acknowledgement.
Returns: boolean  Whether to start the backchannel retry timer.
code »
shouldUseSecondaryDomains() boolean
Determines whether to use a secondary domain when the server gives us a host prefix. This allows us to work around browser per-domain connection limits. Currently, we use secondary domains when using Trident's ActiveXObject, because it supports cross-domain requests out of the box. Note that in IE10 we no longer use ActiveX since it's not supported in Metro mode and IE10 supports XHR streaming. If you need to use secondary domains on other browsers and IE10, you have two choices: 1) If you only care about browsers that support CORS (https://developer.mozilla.org/en-US/docs/HTTP_access_control), you can use #setSupportsCrossDomainXhrs and set the appropriate CORS response headers on the server. 2) Or, override this method in a subclass, and make sure that those browsers use some messaging mechanism that works cross-domain (e.g iframes and window.postMessage).
Returns: boolean  Whether to use secondary domains.
code »
signalError_(error)
Signals an error has occurred.
Arguments:
error : goog.net.BrowserChannel.Error
The error code for the failure.
code »
startBackChannel_()
Begins a new back channel operation to the server.
code »
startForwardChannel_(opt_retryRequest)
Begins a new forward channel operation to the server.
Arguments:
opt_retryRequest : goog.net.ChannelRequest=
A failed request to retry.
code »
testConnectionBlocked(testChannel)
Callback from BrowserTestChannel for when the channel is blocked.
Arguments:
testChannel : goog.net.BrowserTestChannel
The BrowserTestChannel.
code »
testConnectionFailure(testChannelerrorCode)
Callback from BrowserTestChannel for when the channel has an error.
Arguments:
testChannel : goog.net.BrowserTestChannel
The BrowserTestChannel.
errorCode : goog.net.ChannelRequest.Error
The error code of the failure.
code »
testConnectionFinished(testChanneluseChunked)
Callback from BrowserTestChannel for when the channel is finished.
Arguments:
testChannel : goog.net.BrowserTestChannel
The BrowserTestChannel.
useChunked : boolean
Whether we can chunk responses.
code »
testGoogleComCallback_(networkUp)
Callback for testGoogleCom during error handling.
Arguments:
networkUp : boolean
Whether the network is up.
code »

Instance Properties

allowChunkedMode_ :
No description.
Code »
allowHostPrefix_ :
No description.
Code »
backChannelAttemptId_ :
The attempt id for the current back channel request. Starts at 1 and increments for each reconnect. The server uses this to log if our connection is flaky or not.
Code »
backChannelRequest_ : goog.net.ChannelRequest
The ChannelRequest object for the backchannel.
Code »
backChannelRetryCount_ :
Number of times it a row that we have retried the current back channel request and received no data.
Code »
backChannelTimerId_ :
Timer identifier for asynchronously making a back channel request.
Code »
backChannelUri_ : goog.Uri
The absolute URI for the backchannel request.
Code »
baseRetryDelayMs_ :
The base part of the time before firing next retry request. Default is 5 seconds. Note that a random delay is added (see retryDelaySeedMs_) for all retries, and linear backoff is applied to the sum for subsequent retries.
Code »
channelDebug_ : goog.net.ChannelDebug
The channel debug used for browserchannel logging
Code »
channelVersion_ :
The channel version that we negotiated with the server for this session. Starts out as the version we request, and then is changed to the negotiated version after the initial open.
Code »
clientVersion_ :
The application specific version that is passed to the server.
Code »
connectionTest_ : goog.net.BrowserTestChannel
The BrowserTestChannel object which encapsulates the logic for determining interesting network conditions about the client.
Code »
deadBackChannelTimerId_ :
Timer identifier for the timer that waits for us to retry the backchannel in the case where it is dead and no longer receiving data.
Code »
extraHeaders_ :
Extra HTTP headers to add to all the requests sent to the server.
Code »
extraParams_ :
Extra parameters to add to all the requests sent to the server.
Code »
failFast_ :
Whether to fail forward-channel requests after one try, or after a few tries.
Code »
firstTestResults_ :
An array of results for the first browser channel test call.
Code »
forwardChannelMaxRetries_ :
Maximum number of attempts to connect to the server for forward channel requests. Defaults to 2.
Code »
forwardChannelRequestTimeoutMs_ :
The timeout in milliseconds for a forward channel request. Defaults to 20 seconds. Note that part of this timeout can be randomized.
Code »
forwardChannelRequest_ : goog.net.ChannelRequest
The current ChannelRequest object for the forwardchannel.
Code »
forwardChannelRetryCount_ :
Number of times we have retried the current forward channel request.
Code »
forwardChannelTimerId_ :
Timer identifier for asynchronously making a forward channel request.
Code »
forwardChannelUri_ : goog.Uri
The absolute URI for the forwardchannel request.
Code »
The handler that receive callbacks for state changes and data.
Code »
hostPrefix_ :
A subdomain prefix for using a subdomain in IE for the backchannel requests.
Code »
lastArrayId_ :
The array identifier of the last array received from the server for the backchannel request.
Code »
lastPostResponseArrayId_ :
The array identifier of the last array sent by the server that we know about.
Code »
lastStatusCode_ :
The last status code received.
Code »
nextMapId_ :
The id to use for the next outgoing map. This identifier uniquely identifies a sent map.
Code »
nextRid_ :
The next id to use for the RID (request identifier) parameter. This identifier uniquely identifies the forward channel request.
Code »
outgoingMaps_ :
An array of queued maps that need to be sent to the server.
Code »
Parser for a response payload. Defaults to use goog.json.unsafeParse. The parser should return an array.
Code »
path_ :
The relative path (in the context of the the page hosting the browser channel) for making requests to the server.
Code »
pendingMaps_ :
An array of dequeued maps that we have either received a non-successful response for, or no response at all, and which therefore may or may not have been received by the server.
Code »
readyStateChangeThrottleMs_ :
A throttle time in ms for readystatechange events for the backchannel. Useful for throttling when ready state is INTERACTIVE (partial data). This throttle is useful if the server sends large data chunks down the backchannel. It prevents examining XHR partial data on every readystate change event. This is useful because large chunks can trigger hundreds of readystatechange events, each of which takes ~5ms or so to handle, in turn making the UI unresponsive for a significant period. If set to zero no throttle is used.
Code »
retryDelaySeedMs_ :
A random time between 0 and this number of MS is added to the baseRetryDelayMs_. Default is 10 seconds.
Code »
secondTestResults_ :
The results of the second browser channel test. True implies the connection is buffered, False means unbuffered, null means that the results are not available.
Code »
state_ :
The current state of the BrowserChannel. It should be one of the goog.net.BrowserChannel.State constants.
Code »
supportsCrossDomainXhrs_ :
Whether cross origin requests are supported for the browser channel. See goog.net.XhrIo#setWithCredentials.
Code »
useChunked_ :
Whether the client's network conditions can support chunked responses.
Code »

Static Methods

goog.net.BrowserChannel.createChannelRequest(channelchannelDebugopt_sessionIdopt_requestIdopt_retryId) !goog.net.ChannelRequest
Instantiates a ChannelRequest with the given parameters. Overidden in tests.
Arguments:
channel : goog.net.BrowserChannel | goog.net.BrowserTestChannel
The BrowserChannel that owns this request.
channelDebug : goog.net.ChannelDebug
A ChannelDebug to use for logging.
opt_sessionId : string=
The session id for the channel.
opt_requestId : string | number=
The request id for this request.
opt_retryId : number=
The retry id for this request.
Returns: !goog.net.ChannelRequest  The created channel request.
code »
goog.net.BrowserChannel.getStatEventTarget() goog.events.EventTarget
Returns the singleton event target for stat events.
Returns: goog.events.EventTarget  The event target for stat events.
code »
goog.net.BrowserChannel.isFatalError_(errorstatusCode) boolean
Returns whether or not the given error/status combination is fatal or not. On fatal errors we immediately close the session rather than retrying the failed request.
Arguments:
error : ?goog.net.ChannelRequest.Error
The error code for the failed request.
statusCode : number
The last HTTP status code.
Returns: boolean  Whether or not the error is fatal.
code »
goog.net.BrowserChannel.notifyStatEvent(stat)
Helper function to call the stat event callback.
Arguments:
stat : goog.net.BrowserChannel.Stat
The stat.
code »
goog.net.BrowserChannel.notifyTimingEvent(sizerttretries)
Helper function to notify listeners about POST request performance.
Arguments:
size : number
Number of characters in the POST data.
rtt : number
The amount of time from POST start to response.
retries : number
The number of times the POST had to be retried.
code »
goog.net.BrowserChannel.onEndExecution()
Helper function to call the end hook
code »
goog.net.BrowserChannel.onStartExecution()
Helper function to call the start hook
code »
goog.net.BrowserChannel.setEndThreadExecutionHook(endHook)
Allows the application to set an execution hooks for when BrowserChannel stops processing requests. This is useful to track timing or logging special information. The function takes no parameters and return void.
Arguments:
endHook : Function
The function for the end hook.
code »
goog.net.BrowserChannel.setStartThreadExecutionHook(startHook)
Allows the application to set an execution hooks for when BrowserChannel starts processing requests. This is useful to track timing or logging special information. The function takes no parameters and return void.
Arguments:
startHook : Function
The function for the start hook.
code »
goog.net.BrowserChannel.setTimeout(fnms) number
Wrapper around SafeTimeout which calls the start and end execution hooks with a try...finally block.
Arguments:
fn : Function
The callback function.
ms : number
The time in MS for the timer.
Returns: number  The ID of the timer.
code »

Static Properties

goog.net.BrowserChannel.BACK_CHANNEL_MAX_RETRIES :
Maximum number of attempts to connect to the server for back channel requests.
Code »
goog.net.BrowserChannel.Event :
Events fired by BrowserChannel and associated objects
Code »
goog.net.BrowserChannel.FORWARD_CHANNEL_RETRY_TIMEOUT :
The timeout in milliseconds for a forward channel request.
Code »
goog.net.BrowserChannel.INACTIVE_CHANNEL_RETRY_FACTOR :
When retrying for an inactive channel, we will multiply the total delay by this number.
Code »
goog.net.BrowserChannel.LATEST_CHANNEL_VERSION :
The latest protocol version that this class supports. We request this version from the server when opening the connection. Should match com.google.net.browserchannel.BrowserChannel.LATEST_CHANNEL_VERSION.
Code »
goog.net.BrowserChannel.LogSaver :
A LogSaver that can be used to accumulate all the debug logs for BrowserChannels so they can be sent to the server when a problem is detected.
Code »
goog.net.BrowserChannel.MAGIC_RESPONSE_COOKIE :
The normal response for forward channel requests. Used only before version 8 of the protocol.
Code »
goog.net.BrowserChannel.MAX_MAPS_PER_REQUEST_ :
The maximum number of maps that can be sent in one POST. Should match com.google.net.browserchannel.BrowserChannel.MAX_MAPS_PER_REQUEST.
Code »
goog.net.BrowserChannel.OUTSTANDING_DATA_BACKCHANNEL_RETRY_CUTOFF :
A guess at a cutoff at which to no longer assume the backchannel is dead when we are slow to receive data. Number in bytes. Assumption: The worst bandwidth we work on is 50 kilobits/sec 50kbits/sec * (1 byte / 8 bits) * 6 sec dead backchannel timeout
Code »
goog.net.BrowserChannel.RTT_ESTIMATE :
A number in MS of how long we guess the maxmium amount of time a round trip to the server should take. In the future this could be substituted with a real measurement of the RTT.
Code »
goog.net.BrowserChannel.endExecutionHook_ :
Application provided execution hook for the end hook.
Code »
goog.net.BrowserChannel.startExecutionHook_ :
Application provided execution hook for the start hook.
Code »
goog.net.BrowserChannel.statEventTarget_ : goog.events.EventTarget
Singleton event target for firing stat events
Code »

Enumerations

goog.net.BrowserChannel.ChannelType_ :
Internal enum type for the two browser channel channel types.
Constants:
BACK_CHANNEL
No description.
FORWARD_CHANNEL
No description.
Code »
goog.net.BrowserChannel.Error :
Enum type for identifying a BrowserChannel error.
Constants:
ACTIVE_X_BLOCKED
No description.
BAD_DATA
No description.
BAD_RESPONSE
No description.
BLOCKED
No description.
LOGGED_OUT
No description.
NETWORK
No description.
NO_DATA
No description.
OK
No description.
REQUEST_FAILED
No description.
STOP
No description.
UNKNOWN_SESSION_ID
No description.
Code »
goog.net.BrowserChannel.ServerReachability :
Types of events which reveal information about the reachability of the server.
Constants:
BACK_CHANNEL_ACTIVITY
No description.
REQUEST_FAILED
No description.
REQUEST_MADE
No description.
REQUEST_SUCCEEDED
No description.
Code »
goog.net.BrowserChannel.Stat :
Enum that identifies events for statistics that are interesting to track. TODO(user) - Change name not to use Event or use EventTarget
Constants:
ACTIVE_X_BLOCKED
No description.
BACKCHANNEL_DEAD
No description.
BACKCHANNEL_MISSING
No description.
BROWSER_OFFLINE
No description.
CHANNEL_BLOCKED
No description.
CONNECT_ATTEMPT
No description.
ERROR_NETWORK
No description.
ERROR_OTHER
No description.
NOPROXY
No description.
PROXY
No description.
REQUEST_BAD_DATA
No description.
REQUEST_BAD_STATUS
No description.
REQUEST_INCOMPLETE_DATA
No description.
REQUEST_NO_DATA
No description.
REQUEST_TIMEOUT
No description.
REQUEST_UNKNOWN_SESSION_ID
No description.
TEST_STAGE_ONE_FAILED
No description.
TEST_STAGE_ONE_START
No description.
TEST_STAGE_TWO_DATA_BOTH
No description.
TEST_STAGE_TWO_DATA_ONE
No description.
TEST_STAGE_TWO_DATA_TWO
No description.
TEST_STAGE_TWO_FAILED
No description.
TEST_STAGE_TWO_START
No description.
Code »
goog.net.BrowserChannel.State :
Enum type for the browser channel state machine.
Constants:
CLOSED
No description.
INIT
No description.
OPENED
No description.
OPENING
No description.
Code »

Package net

Package Reference