Implements It2MeBrowserTest CancelShare and VerifyAccessCodeNotReusable

remoting/webapp/crd/js/desktop_remoting.js

 // Copyright 2014 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 /**
  * @fileoverview
  * This class implements the functionality that is specific to desktop
  * remoting ("Chromoting" or CRD).
  */
 
@@ skipping 233 matching lines @@
 
 /**
  * Called when the current session's connection has failed.
  *
  * @param {remoting.SessionConnector} connector
  * @param {!remoting.Error} error
  * @return {void} Nothing.
  */
 remoting.DesktopRemoting.prototype.handleConnectionFailed = function(
     connector, error) {
-  /** @type {remoting.DesktopRemoting} */
-  var that = this;
+  if (error.tag === remoting.Error.Tag.HOST_IS_OFFLINE) {
+    var mode = this.app_.getSessionConnector().getConnectionMode();
+    if (mode === remoting.DesktopConnectedView.Mode.IT2ME) {
+      // HOST_IS_OFFLINE during an It2Me connection indicates the host portion
+      // of the access code is invalid, just return INVALID_ACCESS_CODE.
+      // TODO(kelvinp): Move this code to It2MeConnectFlow once it is owned
+      // by remoting.DesktopRemoting.
+      error = remoting.Error.INVALID_ACCESS_CODE;

[Jamie, 2015/03/13 18:38:47]

There are two cases to consider here: where the directory returns an error when
we query the host id (probably 404, but I'm not sure) and where the host returns
a JID, but we're not able to connect to it. It seems like the latter case is a
real error (though it might happen if there are replication delays in the
directory--Renato would know better), whereas the former is not handled here.

[kelvinp, 2015/03/13 18:55:25]

For case 1)
If the directory returns 404, It2MeConnectFlow will return InvalidAccessCode. 
See
https://code.google.com/p/chromium/codesearch#chromium/src/remoting/webapp/cr...

For case 2)
From debugging, I noticed that case 2 is actually happening.  The host is
returned with a valid JID but we just can't connect to it. I will wait and see
what Renato's feedback is.

[rmsousa, 2015/03/13 22:14:27]

HOST_IS_OFFLINE does not indicate that the host portion of the code is invalid.
It means a different thing. it means that the host is _valid_, that we got a JID
from the directory, tried to connect to it, and got *no response*. (e.g. because
the host user disconnected). HOST_IS_OFFLINE is the right response for this
case.

A different issue is a 404 when getting the host (host portion is invalid).
InvalidAccessCode here is correct. THIS one is *theoretically* subject to
replication delays (host registers itself to share the machine, client tries
that host id and it hasn't shown up yet), but we use some "sharding" heuristic
to avoid that situation (each shard generates its own ids, and when the client
tries to fetch the host that shard is consulted first), so the actual
probability of a replication-related issue here is close to nil. I think it's
safe to use InvalidAccessCode for 404s.

When the host portion is valid but the PIN portion is invalid, I suppose we
already return INVALID_ACCESS_CODE, so that's correct.

There's also another case - a host is valid, but someone already used that
access code. In that case, the host will actively reject the second connection.
I can't remember what the error code for this is, I'm guessing InvalidAccessCode
as well.

I'm not sure why you're not able to connect to the host JID, but that's not
directory related.

+    } else if (this.refreshHostJidIfOffline_) {
+      this.refreshHostJidIfOffline_ = false;
+      var that = this;
 
-  /** @param {boolean} success */
-  var onHostListRefresh = function(success) {
-    if (success) {
-      var host = remoting.hostList.getHostForId(connector.getHostId());
-      if (host) {
-        connector.retryConnectMe2Me(host);
-        return;
-      }
+      var onHostListRefresh = function(/** boolean */ success) {
+        if (success) {
+          var host = remoting.hostList.getHostForId(connector.getHostId());
+          if (host) {
+            connector.retryConnectMe2Me(host);
+            return;
+          }
+        }
+        that.handleError(error);
+      };
+
+      // The plugin will be re-created when the host finished refreshing
+      remoting.hostList.refresh(onHostListRefresh);
+      return;
     }
-    that.handleError(error);
-  };
-
-  if (error.tag == remoting.Error.Tag.HOST_IS_OFFLINE &&
-      that.refreshHostJidIfOffline_) {
-    that.refreshHostJidIfOffline_ = false;
-    // The plugin will be re-created when the host finished refreshing
-    remoting.hostList.refresh(onHostListRefresh);
-  } else {
-    this.handleError(error);
   }
+  this.handleError(error);
 };
 
 /**
  * Called when the current session has reached the point where the host has
  * started streaming video frames to the client.
  *
  * @return {void} Nothing.
  */
 remoting.DesktopRemoting.prototype.handleVideoStreamingStarted = function() {
 };
@@ skipping 37 matching lines @@
   } else {
     remoting.setMode(remoting.AppMode.CLIENT_CONNECT_FAILED_ME2ME);
   }
 };
 
 /**
  * No cleanup required for desktop remoting.
  */
 remoting.DesktopRemoting.prototype.handleExit = function() {
 };