Add assigner support to Blimp

blimp/client/session/blimp_client_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/client/session/blimp_client_session.h"
 
 #include <string>
 #include <vector>
 
 #include "base/command_line.h"
 #include "base/numerics/safe_conversions.h"
 #include "base/strings/string_number_conversions.h"
+#include "base/thread_task_runner_handle.h"
 #include "base/threading/sequenced_task_runner_handle.h"
 #include "blimp/client/app/blimp_client_switches.h"
 #include "blimp/client/feature/navigation_feature.h"
 #include "blimp/client/feature/render_widget_feature.h"
 #include "blimp/client/feature/tab_control_feature.h"
 #include "blimp/net/blimp_message_processor.h"
 #include "blimp/net/blimp_message_thread_pipe.h"
 #include "blimp/net/browser_connection_handler.h"
 #include "blimp/net/client_connection_manager.h"
 #include "blimp/net/common.h"
@@ skipping 76 matching lines @@
   // actual sender of the |outgoing_pipe|.
   scoped_ptr<BlimpMessageProcessor> outgoing_message_processor =
       browser_connection_handler_->RegisterFeature(type, incoming_proxy.get());
   outgoing_pipe->set_target_processor(outgoing_message_processor.get());
 
   incoming_proxies_.push_back(std::move(incoming_proxy));
   outgoing_pipes_.push_back(std::move(outgoing_pipe));
   outgoing_message_processors_.push_back(std::move(outgoing_message_processor));
 }
 
-BlimpClientSession::BlimpClientSession(
-    scoped_ptr<AssignmentSource> assignment_source)
-    : assignment_source_(std::move(assignment_source)),
-      io_thread_("BlimpIOThread"),
+BlimpClientSession::BlimpClientSession()
+    : io_thread_("BlimpIOThread"),
       tab_control_feature_(new TabControlFeature),
       navigation_feature_(new NavigationFeature),
       render_widget_feature_(new RenderWidgetFeature),
       net_components_(new ClientNetworkComponents),
       weak_factory_(this) {
   base::Thread::Options options;
   options.message_loop_type = base::MessageLoop::TYPE_IO;
   io_thread_.StartWithOptions(options);
 
+  assignment_source_.reset(new AssignmentSource(
+      base::ThreadTaskRunnerHandle::Get(), io_thread_.task_runner()));
+
   // Register features' message senders and receivers.
   tab_control_feature_->set_outgoing_message_processor(
       RegisterFeature(BlimpMessage::TAB_CONTROL, tab_control_feature_.get()));
   navigation_feature_->set_outgoing_message_processor(
       RegisterFeature(BlimpMessage::NAVIGATION, navigation_feature_.get()));
   render_widget_feature_->set_outgoing_input_message_processor(
       RegisterFeature(BlimpMessage::INPUT, render_widget_feature_.get()));
   render_widget_feature_->set_outgoing_compositor_message_processor(
       RegisterFeature(BlimpMessage::COMPOSITOR, render_widget_feature_.get()));
 
   // We don't expect to send any RenderWidget messages, so don't save the
   // outgoing BlimpMessageProcessor in the RenderWidgetFeature.
   RegisterFeature(BlimpMessage::RENDER_WIDGET, render_widget_feature_.get());
 
   // Initialize must only be posted after the RegisterFeature calls have
   // completed.
   io_thread_.task_runner()->PostTask(
       FROM_HERE, base::Bind(&ClientNetworkComponents::Initialize,
                             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::Connect(const std::string& token) {
+  assignment_source_->GetAssignment(
+      token, base::Bind(&BlimpClientSession::ConnectWithAssignment,
+                        weak_factory_.GetWeakPtr()));
 }
 
-void BlimpClientSession::ConnectWithAssignment(const Assignment& assignment) {
+void BlimpClientSession::ConnectWithAssignment(AssignmentSourceResult result,
+                                               const Assignment& assignment) {
+  if (result != ASSIGNMENT_SOURCE_RESULT_OKAY) {
+    DVLOG(1) << "Assignment request failed: " << result;
+    return;

[Kevin M, 2016/02/12 19:45:27]

Should the subclasses be filtering out the erroneous calls by this point? That's
one of the reasons why I'm a little iffy about going back and forth between a
subclass and a superclass.

[David Trainor- moved to gerrit, 2016/02/17 21:09:48]

Yeah good point.  I changed this to always call an OnXXX method like you
suggested.

+  }
+
   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) {
   // Creates an outgoing pipe and a proxy for forwarding messages
@@ skipping 29 matching lines @@
 NavigationFeature* BlimpClientSession::GetNavigationFeature() const {
   return navigation_feature_.get();
 }
 
 RenderWidgetFeature* BlimpClientSession::GetRenderWidgetFeature() const {
   return render_widget_feature_.get();
 }
 
 }  // namespace client
 }  // namespace blimp