Add TabControlFeature to BlimpClientContextImpl

blimp/client/core/blimp_client_context_impl.cc

 // 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/core/blimp_client_context_impl.h"
 
 #include "base/bind.h"
 #include "base/memory/ptr_util.h"
 #include "base/message_loop/message_loop.h"
 #include "base/threading/sequenced_task_runner_handle.h"
@@ skipping 31 matching lines @@
 #endif  // defined(OS_ANDROID)
 }
 
 BlimpClientContextImpl::BlimpClientContextImpl(
     scoped_refptr<base::SingleThreadTaskRunner> io_thread_task_runner,
     scoped_refptr<base::SingleThreadTaskRunner> file_thread_task_runner)
     : BlimpClientContext(),
       io_thread_task_runner_(io_thread_task_runner),
       file_thread_task_runner_(file_thread_task_runner),
       blimp_contents_manager_(new BlimpContentsManager),
+      tab_control_feature_(new TabControlFeature),
       weak_factory_(this) {
   net_components_.reset(new ClientNetworkComponents(
       base::MakeUnique<CrossThreadNetworkEventObserver>(
           weak_factory_.GetWeakPtr(), base::SequencedTaskRunnerHandle::Get())));
 
   // The |thread_pipe_manager_| must be set up correctly before features are
   // registered.
   thread_pipe_manager_ = base::MakeUnique<ThreadPipeManager>(
       io_thread_task_runner_, net_components_->GetBrowserConnectionHandler());
 
+  RegisterFeatures();
+
   // Initialize must only be posted after the calls features have been
   // registered.
   io_thread_task_runner_->PostTask(
       FROM_HERE, base::Bind(&ClientNetworkComponents::Initialize,
                             base::Unretained(net_components_.get())));
 }
 
 BlimpClientContextImpl::~BlimpClientContextImpl() {
   io_thread_task_runner_->DeleteSoon(FROM_HERE, net_components_.release());
 }
 
 void BlimpClientContextImpl::SetDelegate(BlimpClientContextDelegate* delegate) {
   delegate_ = delegate;
 }
 
 std::unique_ptr<BlimpContents> BlimpClientContextImpl::CreateBlimpContents() {
   std::unique_ptr<BlimpContents> blimp_contents =
       blimp_contents_manager_->CreateBlimpContents();
   delegate_->AttachBlimpContentsHelpers(blimp_contents.get());
+
+  BlimpContentsImpl* blimp_contents_impl =
+      static_cast<BlimpContentsImpl*>(blimp_contents.get());
+  blimp_contents_impl->SetTabControlFeature(tab_control_feature_.get());

[nyquist, 2016/08/16 20:41:04]

Did you consider doing this in the constructor instead? That would probably mean
passing a raw pointer of the feature to BlimpContentsManager of course.

[Menglin, 2016/08/16 21:10:09]

Do you mean BlimpContentsImpl::BlimpContentsImpl(int id, TabControlFeature*
tab_control_feature) so that a BlimpContentsImpl is guaranteed to have a
TabControlFeature? Yeah if that's the case, we can do this in the constructor.

question not for this CL but in the future, are the other features (navigation
feature, ime feature) going to be added in similar way?

[nyquist, 2016/08/16 21:41:40]

Yes, that's what I meant. I don't feel strongly about it though, but it surely
seems like a dependency of BlimpContentsImpl, so it feels like it should be in
the constructor.

And about the future: Yeah, they will have to be done in a similar manner.

[Menglin, 2016/08/17 19:48:46]

Done.

+
   return blimp_contents;
 }
 
 void BlimpClientContextImpl::Connect(const std::string& client_auth_token) {
   if (!assignment_source_) {
     assignment_source_.reset(new AssignmentSource(
         GetAssignerURL(), io_thread_task_runner_, file_thread_task_runner_));
   }
 
   VLOG(1) << "Trying to get assignment.";
   assignment_source_->GetAssignment(
       client_auth_token,
       base::Bind(&BlimpClientContextImpl::ConnectWithAssignment,
                  weak_factory_.GetWeakPtr()));
 }
 
 void BlimpClientContextImpl::OnConnected() {}
 
 void BlimpClientContextImpl::OnDisconnected(int result) {}
 
+TabControlFeature* BlimpClientContextImpl::GetTabControlFeature() const {
+  return tab_control_feature_.get();
+}
+
 GURL BlimpClientContextImpl::GetAssignerURL() {
   return GURL(kDefaultAssignerUrl);
 }
 
 void BlimpClientContextImpl::ConnectWithAssignment(
     AssignmentRequestResult result,
     const Assignment& assignment) {
   VLOG(1) << "Assignment result: " << result;
 
   if (delegate_) {
     delegate_->OnAssignmentConnectionAttempted(result, assignment);
   }
 
   if (result != ASSIGNMENT_REQUEST_RESULT_OK) {
     LOG(ERROR) << "Assignment failed, reason: " << result;
     return;
   }
 
   io_thread_task_runner_->PostTask(
       FROM_HERE,
       base::Bind(&ClientNetworkComponents::ConnectWithAssignment,
                  base::Unretained(net_components_.get()), assignment));
 }
 
+void BlimpClientContextImpl::RegisterFeatures() {
+  // Register features' message senders and receivers.
+  tab_control_feature_->set_outgoing_message_processor(
+      thread_pipe_manager_->RegisterFeature(BlimpMessage::kTabControl,
+                                            tab_control_feature_.get()));
+}
+
 }  // namespace client
 }  // namespace blimp