[Blimp] Adds blimp engine browser test framework and LoadUrl test.

blimp/engine/session/blimp_engine_session.cc

 // Copyright 2015 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/engine/session/blimp_engine_session.h"
 
 #include <string>
 
 #include "base/command_line.h"
 #include "base/memory/ptr_util.h"
@@ skipping 84 matching lines @@
 }
 
 uint16_t GetListeningPort() {
   unsigned port_parsed = 0;
   if (!base::StringToUint(
           base::CommandLine::ForCurrentProcess()->GetSwitchValueASCII(
               kEnginePort),
           &port_parsed)) {
     return kDefaultPort;
   }
-  if (port_parsed == 0 ||
-      port_parsed > 65535) {
-    LOG(FATAL) << "--engine-port must be a value between 1 and 65535.";
+  if (port_parsed > 65535) {
+    LOG(FATAL) << "--engine-port must be a value between 0 and 65535.";
     return kDefaultPort;
   }
   return port_parsed;
 }
 
 }  // namespace
 
 // EngineNetworkComponents is created by the BlimpEngineSession on the UI
 // thread, and then used and destroyed on the IO thread.
 class EngineNetworkComponents : public ConnectionHandler,
                                 public ConnectionErrorObserver {
  public:
   // |net_log|: The log to use for network-related events.
   // |quit_closure|: A closure which will terminate the engine when
   //                 invoked.
   EngineNetworkComponents(net::NetLog* net_log,
                           const base::Closure& quit_closure);
   ~EngineNetworkComponents() override;
 
   // Sets up network components and starts listening for incoming connection.
   // This should be called after all features have been registered so that
   // received messages can be properly handled.
   void Initialize(const std::string& client_token);
 
+  uint16_t GetPortForTesting() { return port_; }
+
   BrowserConnectionHandler* GetBrowserConnectionHandler();
 
  private:
   // ConnectionHandler implementation.
   void HandleConnection(std::unique_ptr<BlimpConnection> connection) override;
 
   // ConnectionErrorObserver implementation.
   // Signals the engine session that an authenticated connection was
   // terminated.
   void OnConnectionError(int error) override;
 
   net::NetLog* net_log_;
   base::Closure quit_closure_;
+  uint16_t port_ = 0;
 
   std::unique_ptr<BrowserConnectionHandler> connection_handler_;
   std::unique_ptr<EngineAuthenticationHandler> authentication_handler_;
   std::unique_ptr<EngineConnectionManager> connection_manager_;
 
   DISALLOW_COPY_AND_ASSIGN(EngineNetworkComponents);
 };
 
 EngineNetworkComponents::EngineNetworkComponents(
     net::NetLog* net_log,
@@ skipping 14 matching lines @@
   // to |this| (which will then pass it to |connection_handler_|.
   authentication_handler_ =
       base::WrapUnique(new EngineAuthenticationHandler(this, client_token));
 
   // Plumb unauthenticated connections to |authentication_handler_|.
   connection_manager_ = base::WrapUnique(
       new EngineConnectionManager(authentication_handler_.get()));
 
   // Adds BlimpTransports to connection_manager_.
   net::IPEndPoint address(GetIPv4AnyAddress(), GetListeningPort());
-  connection_manager_->AddTransport(
-      base::WrapUnique(new TCPEngineTransport(address, net_log_)));
+  TCPEngineTransport* transport = new TCPEngineTransport(address, net_log_);
+  connection_manager_->AddTransport(base::WrapUnique(transport));
+
+  transport->GetLocalAddress(&address);
+  port_ = address.port();
 }
 
 void EngineNetworkComponents::HandleConnection(
     std::unique_ptr<BlimpConnection> connection) {
   // Observe |connection| for disconnection events.
   connection->AddConnectionErrorObserver(this);
   connection_handler_->HandleConnection(std::move(connection));
 }
 
 void EngineNetworkComponents::OnConnectionError(int error) {
@@ skipping 71 matching lines @@
 
   // Initialize must only be posted after the RegisterFeature calls have
   // completed.
   content::BrowserThread::PostTask(
       content::BrowserThread::IO, FROM_HERE,
       base::Bind(&EngineNetworkComponents::Initialize,
                  base::Unretained(net_components_.get()),
                  engine_config_->client_token()));
 }
 
+void BlimpEngineSession::GetEnginePortForTesting(
+    const GetPortCallback& callback) {
+  content::BrowserThread::PostTaskAndReplyWithResult(
+      content::BrowserThread::IO, FROM_HERE,
+      base::Bind(&EngineNetworkComponents::GetPortForTesting,
+                 base::Unretained(net_components_.get())),
+      callback);
+}
+
 void BlimpEngineSession::RegisterFeatures() {
   thread_pipe_manager_.reset(new ThreadPipeManager(
       content::BrowserThread::GetMessageLoopProxyForThread(
           content::BrowserThread::IO),
       content::BrowserThread::GetMessageLoopProxyForThread(
           content::BrowserThread::UI),
       net_components_->GetBrowserConnectionHandler()));
 
   // Register features' message senders and receivers.
   tab_control_message_sender_ =
@@ skipping 352 matching lines @@
 
   aura::Window* parent = window_tree_host_->window();
   aura::Window* content = web_contents_->GetNativeView();
   if (!parent->Contains(content))
     parent->AddChild(content);
   content->Show();
 }
 
 }  // namespace engine
 }  // namespace blimp