Add initial framework for AssignmentSource.

This CL moves reading the command line params for engine connection
to a default AssignmentSource instead of being a part of
BlimpClientSession. This is required going forward to be able to
implement something that communicates with the real assigner.

In addition this CL also makes the connection step asynchronous
instead of happening during the construction of the
BlimpClientSession. This is important so that going forward, the
request to get an assignment does not block startup.

BUG=582668

Review URL: https://codereview.chromium.org/1648383004

Cr-Commit-Position: refs/heads/master@{#372892}

12 files changed, 225 insertions, 73 deletions

diff --git a/blimp/client/BUILD.gn b/blimp/client/BUILD.gn
index 8bd3927..f0c5880 100644
--- a/blimp/client/BUILD.gn
+++ b/blimp/client/BUILD.gn
@@ -16,6 +16,8 @@ component("blimp_client") {
     "app/blimp_startup.cc",
     "app/blimp_startup.h",
     "blimp_client_export.h",
+    "session/assignment_source.cc",
+    "session/assignment_source.h",
     "session/blimp_client_session.cc",
     "session/blimp_client_session.h",
   ]
diff --git a/blimp/client/app/android/blimp_client_session_android.cc b/blimp/client/app/android/blimp_client_session_android.cc
index d452abd..97b8372 100644
--- a/blimp/client/app/android/blimp_client_session_android.cc
+++ b/blimp/client/app/android/blimp_client_session_android.cc
@@ -4,7 +4,9 @@
 
 #include "blimp/client/app/android/blimp_client_session_android.h"
 
+#include "base/thread_task_runner_handle.h"
 #include "blimp/client/feature/tab_control_feature.h"
+#include "blimp/client/session/assignment_source.h"
 #include "jni/BlimpClientSession_jni.h"
 
 namespace blimp {
@@ -14,7 +16,10 @@ const int kDummyTabId = 0;
 }  // namespace
 
 static jlong Init(JNIEnv* env, const JavaParamRef<jobject>& jobj) {
-  return reinterpret_cast<intptr_t>(new BlimpClientSessionAndroid(env, jobj));
+  scoped_ptr<AssignmentSource> assignment_source = make_scoped_ptr(
+      new AssignmentSource(base::ThreadTaskRunnerHandle::Get()));
+  return reinterpret_cast<intptr_t>(
+      new BlimpClientSessionAndroid(env, jobj, std::move(assignment_source)));
 }
 
 // static
@@ -32,8 +37,9 @@ BlimpClientSessionAndroid* BlimpClientSessionAndroid::FromJavaObject(
 
 BlimpClientSessionAndroid::BlimpClientSessionAndroid(
     JNIEnv* env,
-    const base::android::JavaParamRef<jobject>& jobj)
-    : BlimpClientSession() {
+    const base::android::JavaParamRef<jobject>& jobj,
+    scoped_ptr<AssignmentSource> assignment_source)
+    : BlimpClientSession(std::move(assignment_source)) {
   java_obj_.Reset(env, jobj);
 
   // Create a single tab's WebContents.
@@ -41,6 +47,12 @@ BlimpClientSessionAndroid::BlimpClientSessionAndroid(
   GetTabControlFeature()->CreateTab(kDummyTabId);
 }
 
+void BlimpClientSessionAndroid::Connect(
+    JNIEnv* env,
+    const base::android::JavaParamRef<jobject>& jobj) {
+  BlimpClientSession::Connect();
+}
+
 BlimpClientSessionAndroid::~BlimpClientSessionAndroid() {}
 
 void BlimpClientSessionAndroid::Destroy(JNIEnv* env,
diff --git a/blimp/client/app/android/blimp_client_session_android.h b/blimp/client/app/android/blimp_client_session_android.h
index bdcdf9b..7ba6d9f 100644
--- a/blimp/client/app/android/blimp_client_session_android.h
+++ b/blimp/client/app/android/blimp_client_session_android.h
@@ -12,15 +12,20 @@
 namespace blimp {
 namespace client {
 
+class AssignmentSource;
+
 class BlimpClientSessionAndroid : public BlimpClientSession {
  public:
   static bool RegisterJni(JNIEnv* env);
   static BlimpClientSessionAndroid* FromJavaObject(JNIEnv* env, jobject jobj);
 
   BlimpClientSessionAndroid(JNIEnv* env,
-                            const base::android::JavaParamRef<jobject>& jobj);
+                            const base::android::JavaParamRef<jobject>& jobj,
+                            scoped_ptr<AssignmentSource> assignment_source);
 
   // Methods called from Java via JNI.
+  void Connect(JNIEnv* env, const base::android::JavaParamRef<jobject>& jobj);
+
   void Destroy(JNIEnv* env, const base::android::JavaParamRef<jobject>& jobj);
 
  private:
diff --git a/blimp/client/app/android/java/src/org/chromium/blimp/BlimpRendererActivity.java b/blimp/client/app/android/java/src/org/chromium/blimp/BlimpRendererActivity.java
index a08407a..23d52e6 100644
--- a/blimp/client/app/android/java/src/org/chromium/blimp/BlimpRendererActivity.java
+++ b/blimp/client/app/android/java/src/org/chromium/blimp/BlimpRendererActivity.java
@@ -116,6 +116,7 @@ public class BlimpRendererActivity extends Activity implements BlimpLibraryLoade
         setContentView(R.layout.blimp_main);
 
         mBlimpClientSession = new BlimpClientSession();
+        mBlimpClientSession.connect();
 
         mBlimpView = (BlimpView) findViewById(R.id.renderer);
         mBlimpView.initializeRenderer(mBlimpClientSession);
diff --git a/blimp/client/app/android/java/src/org/chromium/blimp/session/BlimpClientSession.java b/blimp/client/app/android/java/src/org/chromium/blimp/session/BlimpClientSession.java
index f4bd6ac..b3012d8 100644
--- a/blimp/client/app/android/java/src/org/chromium/blimp/session/BlimpClientSession.java
+++ b/blimp/client/app/android/java/src/org/chromium/blimp/session/BlimpClientSession.java
@@ -21,6 +21,13 @@ public class BlimpClientSession {
     }
 
     /**
+     * Retrieves an assignment and uses it to connect to the engine.
+     */
+    public void connect() {
+        nativeConnect(mNativeBlimpClientSessionAndroidPtr);
+    }
+
+    /**
      * Destroys the native BlimpClientSession.  This class should not be used after this is called.
      */
     public void destroy() {
@@ -38,5 +45,6 @@ public class BlimpClientSession {
     }
 
     private native long nativeInit();
+    private native void nativeConnect(long nativeBlimpClientSessionAndroid);
     private native void nativeDestroy(long nativeBlimpClientSessionAndroid);
 }
diff --git a/blimp/client/app/linux/blimp_client_session_linux.cc b/blimp/client/app/linux/blimp_client_session_linux.cc
index 84317ca..d4491be8 100644
--- a/blimp/client/app/linux/blimp_client_session_linux.cc
+++ b/blimp/client/app/linux/blimp_client_session_linux.cc
@@ -59,8 +59,10 @@ void FakeNavigationFeatureDelegate::OnLoadingChanged(int tab_id, bool loading) {
 
 }  // namespace
 
-BlimpClientSessionLinux::BlimpClientSessionLinux()
-    : event_source_(ui::PlatformEventSource::CreateDefault()),
+BlimpClientSessionLinux::BlimpClientSessionLinux(
+    scoped_ptr<AssignmentSource> assignment_source)
+    : BlimpClientSession(std::move(assignment_source)),
+      event_source_(ui::PlatformEventSource::CreateDefault()),
       navigation_feature_delegate_(new FakeNavigationFeatureDelegate) {
   blimp_display_manager_.reset(new BlimpDisplayManager(gfx::Size(800, 600),
                                                        this,
diff --git a/blimp/client/app/linux/blimp_client_session_linux.h b/blimp/client/app/linux/blimp_client_session_linux.h
index 1a60b0d..119feba 100644
--- a/blimp/client/app/linux/blimp_client_session_linux.h
+++ b/blimp/client/app/linux/blimp_client_session_linux.h
@@ -20,7 +20,8 @@ namespace client {
 class BlimpClientSessionLinux : public BlimpClientSession,
                                 public BlimpDisplayManagerDelegate {
  public:
-  BlimpClientSessionLinux();
+  explicit BlimpClientSessionLinux(
+      scoped_ptr<AssignmentSource> assignment_source);
   ~BlimpClientSessionLinux() override;
 
   // BlimpDisplayManagerDelegate implementation.
diff --git a/blimp/client/app/linux/blimp_main.cc b/blimp/client/app/linux/blimp_main.cc
index 159ee6f..332a793 100644
--- a/blimp/client/app/linux/blimp_main.cc
+++ b/blimp/client/app/linux/blimp_main.cc
@@ -9,11 +9,13 @@
 #include "base/at_exit.h"
 #include "base/command_line.h"
 #include "base/run_loop.h"
+#include "base/thread_task_runner_handle.h"
 #include "base/threading/thread.h"
 #include "blimp/client/app/blimp_startup.h"
 #include "blimp/client/app/linux/blimp_client_session_linux.h"
 #include "blimp/client/feature/navigation_feature.h"
 #include "blimp/client/feature/tab_control_feature.h"
+#include "blimp/client/session/assignment_source.h"
 
 namespace {
 const char kDefaultUrl[] = "https://www.google.com";
@@ -29,8 +31,12 @@ int main(int argc, const char**argv) {
   blimp::client::InitializeLogging();
   blimp::client::InitializeMainMessageLoop();
 
-  blimp::client::BlimpClientSessionLinux session;
+  scoped_ptr<blimp::client::AssignmentSource> assignment_source =
+      make_scoped_ptr(new blimp::client::AssignmentSource(
+          base::ThreadTaskRunnerHandle::Get()));
+  blimp::client::BlimpClientSessionLinux session(std::move(assignment_source));
   session.GetTabControlFeature()->CreateTab(kDummyTabId);
+  session.Connect();
 
   // If there is a non-switch argument to the command line, load that url.
   base::CommandLine::StringVector args =
diff --git a/blimp/client/session/assignment_source.cc b/blimp/client/session/assignment_source.cc
new file mode 100644
index 0000000..271569c
--- /dev/null
+++ b/blimp/client/session/assignment_source.cc
@@ -0,0 +1,76 @@
+// Copyright 2016 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.
+
+#include "blimp/client/session/assignment_source.h"
+
+#include "base/bind.h"
+#include "base/command_line.h"
+#include "base/location.h"
+#include "base/numerics/safe_conversions.h"
+#include "base/strings/string_number_conversions.h"
+#include "blimp/client/app/blimp_client_switches.h"
+#include "net/base/ip_address.h"
+#include "net/base/ip_endpoint.h"
+
+namespace blimp {
+namespace {
+
+// TODO(kmarshall): Take values from configuration data.
+const char kDummyClientToken[] = "MyVoiceIsMyPassport";
+const std::string kDefaultBlimpletIPAddress = "127.0.0.1";
+const uint16_t kDefaultBlimpletTCPPort = 25467;
+
+net::IPAddress GetBlimpletIPAddress() {
+  std::string host;
+  if (base::CommandLine::ForCurrentProcess()->HasSwitch(
+          switches::kBlimpletHost)) {
+    host = base::CommandLine::ForCurrentProcess()->GetSwitchValueASCII(
+        switches::kBlimpletHost);
+  } else {
+    host = kDefaultBlimpletIPAddress;
+  }
+  net::IPAddress ip_address;
+  if (!net::IPAddress::FromIPLiteral(host, &ip_address))
+    CHECK(false) << "Invalid BlimpletAssignment host " << host;
+  return ip_address;
+}
+
+uint16_t GetBlimpletTCPPort() {
+  if (base::CommandLine::ForCurrentProcess()->HasSwitch(
+          switches::kBlimpletTCPPort)) {
+    std::string port_str =
+        base::CommandLine::ForCurrentProcess()->GetSwitchValueASCII(
+            switches::kBlimpletTCPPort);
+    uint port_64t;
+    if (!base::StringToUint(port_str, &port_64t) ||
+        !base::IsValueInRangeForNumericType<uint16_t>(port_64t)) {
+      CHECK(false) << "Invalid BlimpletAssignment port " << port_str;
+    }
+    return base::checked_cast<uint16_t>(port_64t);
+  } else {
+    return kDefaultBlimpletTCPPort;
+  }
+}
+
+}  // namespace
+
+namespace client {
+
+AssignmentSource::AssignmentSource(
+    const scoped_refptr<base::SingleThreadTaskRunner>& main_task_runner)
+    : main_task_runner_(main_task_runner) {}
+
+AssignmentSource::~AssignmentSource() {}
+
+void AssignmentSource::GetAssignment(const AssignmentCallback& callback) {
+  DCHECK(main_task_runner_->BelongsToCurrentThread());
+  Assignment assignment;
+  assignment.ip_endpoint =
+      net::IPEndPoint(GetBlimpletIPAddress(), GetBlimpletTCPPort());
+  assignment.client_token = kDummyClientToken;
+  main_task_runner_->PostTask(FROM_HERE, base::Bind(callback, assignment));
+}
+
+}  // namespace client
+}  // namespace blimp
diff --git a/blimp/client/session/assignment_source.h b/blimp/client/session/assignment_source.h
new file mode 100644
index 0000000..9891d4a
--- /dev/null
+++ b/blimp/client/session/assignment_source.h
@@ -0,0 +1,54 @@
+// Copyright 2016 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.
+
+#ifndef BLIMP_CLIENT_SESSION_ASSIGNMENT_SOURCE_H_
+#define BLIMP_CLIENT_SESSION_ASSIGNMENT_SOURCE_H_
+
+#include <string>
+
+#include "base/callback.h"
+#include "blimp/client/blimp_client_export.h"
+#include "net/base/ip_endpoint.h"
+
+namespace base {
+class SingleThreadTaskRunner;
+}
+
+namespace blimp {
+namespace client {
+
+// An Assignment contains the configuration data needed for a client
+// to connect to the engine.
+struct BLIMP_CLIENT_EXPORT Assignment {
+  net::IPEndPoint ip_endpoint;
+  std::string client_token;
+};
+
+// AssignmentSource provides functionality to find out how a client should
+// connect to an engine.
+class BLIMP_CLIENT_EXPORT AssignmentSource {
+ public:
+  typedef const base::Callback<void(const Assignment&)> AssignmentCallback;
+
+  // The |main_task_runner| should be the task runner for the UI thread because
+  // this will in some cases be used to trigger user interaction on the UI
+  // thread.
+  AssignmentSource(
+      const scoped_refptr<base::SingleThreadTaskRunner>& main_task_runner);
+  virtual ~AssignmentSource();
+
+  // Retrieves a valid assignment for the client and posts the result to the
+  // given callback.
+  void GetAssignment(const AssignmentCallback& callback);
+
+ private:
+  scoped_refptr<base::SingleThreadTaskRunner> main_task_runner_;
+
+  DISALLOW_COPY_AND_ASSIGN(AssignmentSource);
+};
+
+}  // namespace client
+}  // namespace blimp
+
+#endif  // BLIMP_CLIENT_SESSION_ASSIGNMENT_SOURCE_H_
diff --git a/blimp/client/session/blimp_client_session.cc b/blimp/client/session/blimp_client_session.cc
index 3c310f5..e681a0a 100644
--- a/blimp/client/session/blimp_client_session.cc
+++ b/blimp/client/session/blimp_client_session.cc
@@ -28,52 +28,6 @@
 
 namespace blimp {
 namespace client {
-namespace {
-
-// TODO(kmarshall): Take values from configuration data.
-const char kDummyClientToken[] = "MyVoiceIsMyPassport";
-const std::string kDefaultBlimpletIPAddress = "127.0.0.1";
-const uint16_t kDefaultBlimpletTCPPort = 25467;
-
-// A BlimpletAssignment contains the configuration data needed for a client
-// to connect to the engine.
-struct BlimpletAssignment {
-  net::IPEndPoint ip_endpoint;
-};
-
-net::IPAddress GetBlimpletIPAddress() {
-  std::string host;
-  if (base::CommandLine::ForCurrentProcess()->HasSwitch(
-          switches::kBlimpletHost)) {
-    host = base::CommandLine::ForCurrentProcess()->GetSwitchValueASCII(
-        switches::kBlimpletHost);
-  } else {
-    host = kDefaultBlimpletIPAddress;
-  }
-  net::IPAddress ip_address;
-  if (!net::IPAddress::FromIPLiteral(host, &ip_address))
-    CHECK(false) << "Invalid BlimpletAssignment host " << host;
-  return ip_address;
-}
-
-uint16_t GetBlimpletTCPPort() {
-  if (base::CommandLine::ForCurrentProcess()->HasSwitch(
-          switches::kBlimpletTCPPort)) {
-    std::string port_str =
-        base::CommandLine::ForCurrentProcess()->GetSwitchValueASCII(
-            switches::kBlimpletTCPPort);
-    uint port_64t;
-    if (!base::StringToUint(port_str, &port_64t) ||
-        !base::IsValueInRangeForNumericType<uint16_t>(port_64t)) {
-      CHECK(false) << "Invalid BlimpletAssignment port " << port_str;
-    }
-    return base::checked_cast<uint16_t>(port_64t);
-  } else {
-    return kDefaultBlimpletTCPPort;
-  }
-}
-
-}  // namespace
 
 // This class's functions and destruction are all invoked on the IO thread by
 // the BlimpClientSession.
@@ -85,8 +39,12 @@ class ClientNetworkComponents {
 
   ~ClientNetworkComponents() {}
 
-  // Sets up network components and starts to connect to the engine.
-  void Initialize(const net::AddressList& address_list);
+  // Sets up network components.
+  void Initialize();
+
+  // Starts the connection to the engine using the given |assignment|.
+  // It is required to first call Initialize.
+  void ConnectWithAssignment(const Assignment& assignment);
 
   // Invoked by BlimpEngineSession to finish feature registration on IO thread:
   // using |incoming_proxy| as the incoming message processor, and connecting
@@ -111,14 +69,19 @@ class ClientNetworkComponents {
   DISALLOW_COPY_AND_ASSIGN(ClientNetworkComponents);
 };
 
-void ClientNetworkComponents::Initialize(const net::AddressList& address_list) {
+void ClientNetworkComponents::Initialize() {
   DCHECK(!connection_manager_);
   connection_manager_ = make_scoped_ptr(
       new ClientConnectionManager(browser_connection_handler_.get()));
-  connection_manager_->set_client_token(kDummyClientToken);
+}
+
+void ClientNetworkComponents::ConnectWithAssignment(
+    const Assignment& assignment) {
+  DCHECK(connection_manager_);
+  connection_manager_->set_client_token(assignment.client_token);
 
-  connection_manager_->AddTransport(
-      make_scoped_ptr(new TCPClientTransport(address_list, nullptr)));
+  connection_manager_->AddTransport(make_scoped_ptr(new TCPClientTransport(
+      net::AddressList(assignment.ip_endpoint), nullptr)));
 
   connection_manager_->Connect();
 }
@@ -143,12 +106,15 @@ void ClientNetworkComponents::RegisterFeature(
   outgoing_message_processors_.push_back(std::move(outgoing_message_processor));
 }
 
-BlimpClientSession::BlimpClientSession()
-    : io_thread_("BlimpIOThread"),
+BlimpClientSession::BlimpClientSession(
+    scoped_ptr<AssignmentSource> assignment_source)
+    : assignment_source_(std::move(assignment_source)),
+      io_thread_("BlimpIOThread"),
       tab_control_feature_(new TabControlFeature),
       navigation_feature_(new NavigationFeature),
       render_widget_feature_(new RenderWidgetFeature),
-      net_components_(new ClientNetworkComponents) {
+      net_components_(new ClientNetworkComponents),
+      weak_factory_(this) {
   base::Thread::Options options;
   options.message_loop_type = base::MessageLoop::TYPE_IO;
   io_thread_.StartWithOptions(options);
@@ -171,14 +137,25 @@ BlimpClientSession::BlimpClientSession()
   // completed.
   io_thread_.task_runner()->PostTask(
       FROM_HERE, base::Bind(&ClientNetworkComponents::Initialize,
-                            base::Unretained(net_components_.get()),
-                            net::AddressList(GetBlimpletIPEndpoint())));
+                            base::Unretained(net_components_.get())));
 }
 
 BlimpClientSession::~BlimpClientSession() {
   io_thread_.task_runner()->DeleteSoon(FROM_HERE, net_components_.release());
 }
 
+void BlimpClientSession::Connect() {
+  assignment_source_->GetAssignment(base::Bind(
+      &BlimpClientSession::ConnectWithAssignment, weak_factory_.GetWeakPtr()));
+}
+
+void BlimpClientSession::ConnectWithAssignment(const Assignment& assignment) {
+  io_thread_.task_runner()->PostTask(
+      FROM_HERE,
+      base::Bind(&ClientNetworkComponents::ConnectWithAssignment,
+                 base::Unretained(net_components_.get()), assignment));
+}
+
 scoped_ptr<BlimpMessageProcessor> BlimpClientSession::RegisterFeature(
     BlimpMessage::Type type,
     BlimpMessageProcessor* incoming_processor) {
@@ -220,9 +197,5 @@ RenderWidgetFeature* BlimpClientSession::GetRenderWidgetFeature() const {
   return render_widget_feature_.get();
 }
 
-net::IPEndPoint BlimpClientSession::GetBlimpletIPEndpoint() {
-  return net::IPEndPoint(GetBlimpletIPAddress(), GetBlimpletTCPPort());
-}
-
 }  // namespace client
 }  // namespace blimp
diff --git a/blimp/client/session/blimp_client_session.h b/blimp/client/session/blimp_client_session.h
index df50aa8..afcfd53 100644
--- a/blimp/client/session/blimp_client_session.h
+++ b/blimp/client/session/blimp_client_session.h
@@ -10,6 +10,7 @@
 #include "base/memory/scoped_ptr.h"
 #include "base/threading/thread.h"
 #include "blimp/client/blimp_client_export.h"
+#include "blimp/client/session/assignment_source.h"
 #include "blimp/common/proto/blimp_message.pb.h"
 #include "blimp/net/blimp_message_processor.h"
 
@@ -41,7 +42,11 @@ class TabControlFeature;
 // feature proxies must be interacted with on the UI thread.
 class BLIMP_CLIENT_EXPORT BlimpClientSession {
  public:
-  BlimpClientSession();
+  explicit BlimpClientSession(scoped_ptr<AssignmentSource> assignment_source);
+
+  // Uses the AssignmentSource to get an Assignment and then uses the assignment
+  // configuration to connect to the Blimplet.
+  void Connect();
 
   TabControlFeature* GetTabControlFeature() const;
   NavigationFeature* GetNavigationFeature() const;
@@ -50,9 +55,6 @@ class BLIMP_CLIENT_EXPORT BlimpClientSession {
  protected:
   virtual ~BlimpClientSession();
 
-  // Returns the IPEndPoint to use for connecting to the blimplet.
-  net::IPEndPoint GetBlimpletIPEndpoint();
-
  private:
   // Registers a message processor which will receive all messages of the |type|
   // specified.  Returns a BlimpMessageProcessor object for sending messages of
@@ -61,6 +63,14 @@ class BLIMP_CLIENT_EXPORT BlimpClientSession {
       BlimpMessage::Type type,
       BlimpMessageProcessor* incoming_processor);
 
+  // The AssignmentCallback for when an assignment is ready. This will trigger
+  // a connection to the engine.
+  void ConnectWithAssignment(const Assignment& assignment);
+
+  // The AssignmentSource is used when the user of BlimpClientSession calls
+  // Connect() to get a valid assignment and later connect to the engine.
+  scoped_ptr<AssignmentSource> assignment_source_;
+
   base::Thread io_thread_;
   scoped_ptr<TabControlFeature> tab_control_feature_;
   scoped_ptr<NavigationFeature> navigation_feature_;
@@ -75,6 +85,8 @@ class BLIMP_CLIENT_EXPORT BlimpClientSession {
   // on the UI thread.
   std::vector<scoped_ptr<BlimpMessageThreadPipe>> incoming_pipes_;
 
+  base::WeakPtrFactory<BlimpClientSession> weak_factory_;
+
   DISALLOW_COPY_AND_ASSIGN(BlimpClientSession);
 };