Add command line flag to allow testing clients not connected to localhost. Otherwise, restrict conn…

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 <utility>
 
 #include "base/command_line.h"
@@ skipping 69 matching lines @@
   ~FocusRulesImpl() override {}
 
   bool SupportsChildActivation(aura::Window* window) const override {
     return true;
   }
 
  private:
   DISALLOW_COPY_AND_ASSIGN(FocusRulesImpl);
 };
 
-net::IPAddress GetIPv4AnyAddress() {
-  return net::IPAddress(0, 0, 0, 0);
-}
-
 // Proxies calls to TaskRunner::PostTask while stripping the return value,
 // which provides a suitable function prototype for binding a base::Closure.
 void PostTask(const scoped_refptr<base::TaskRunner>& task_runner,
               const base::Closure& closure) {
   task_runner->PostTask(FROM_HERE, closure);
 }
 
 // Returns a closure that quits the current (bind-time) MessageLoop.
 base::Closure QuitCurrentMessageLoopClosure() {
   return base::Bind(&PostTask, base::ThreadTaskRunnerHandle::Get(),
                     base::MessageLoop::QuitWhenIdleClosure());
 }
 
+net::IPAddress GetListeningIPAddress() {

[Wez, 2016/08/30 21:42:00]

nit: I'd suggest just GetListeningAddress, since IP is more-or-less implicit at
this level :)

+  if (base::CommandLine::ForCurrentProcess()->GetSwitchValueASCII(
+          kEngineListenOutside) == "1") {

[Wez, 2016/08/30 21:42:00]

Since this is a Boolean parameter and defaults to false, you can just use
HasSwitch() to determine if the switch is present here, then the app gets run
with --my-option rather than --my-option=1

+    return net::IPAddress::IPv4AllZeros();
+  }
+  return net::IPAddress::IPv4Localhost();
+}
+
 uint16_t GetListeningPort() {
   unsigned port_parsed = 0;
   if (!base::StringToUint(
           base::CommandLine::ForCurrentProcess()->GetSwitchValueASCII(
               kEnginePort),
           &port_parsed)) {
     return kDefaultPort;
   }
   if (port_parsed > 65535) {
     LOG(FATAL) << "--engine-port must be a value between 0 and 65535.";
@@ skipping 70 matching lines @@
       base::MakeUnique<EngineAuthenticationHandler>(this, client_token);
 
   // Plumb unauthenticated connections to |authentication_handler_|.
   connection_manager_ =
       base::MakeUnique<EngineConnectionManager>(authentication_handler_.get());
 
   blob_channel_service_ =
       base::MakeUnique<BlobChannelService>(blob_channel_sender, ui_task_runner);
 
   // Adds BlimpTransports to connection_manager_.
-  net::IPEndPoint address(GetIPv4AnyAddress(), GetListeningPort());
+  net::IPEndPoint address(GetListeningIPAddress(), GetListeningPort());
   TCPEngineTransport* transport = new TCPEngineTransport(address, net_log_);
   connection_manager_->AddTransport(base::WrapUnique(transport));
 
   transport->GetLocalAddress(&address);
   port_ = address.port();
   DVLOG(1) << "Engine port #: " << port_;
 }
 
 void EngineNetworkComponents::HandleConnection(
     std::unique_ptr<BlimpConnection> connection) {
@@ skipping 372 matching lines @@
     parent->AddChild(content);
   content->Show();
 
   tab_ = base::MakeUnique<Tab>(std::move(new_contents), target_tab_id,
                                &render_widget_feature_,
                                navigation_message_sender_.get());
 }
 
 }  // namespace engine
 }  // namespace blimp