Mojo C++ Bindings: Extract AssociatedGroupController from MultiplexRouter

mojo/public/cpp/bindings/lib/interface_endpoint_client.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 "mojo/public/cpp/bindings/lib/interface_endpoint_client.h"
+#include "mojo/public/cpp/bindings/interface_endpoint_client.h"
 
 #include <stdint.h>
 
 #include <utility>
 
 #include "base/bind.h"
 #include "base/location.h"
 #include "base/macros.h"
 #include "base/memory/ptr_util.h"
 #include "base/single_thread_task_runner.h"
 #include "base/stl_util.h"
 #include "mojo/public/cpp/bindings/associated_group.h"
-#include "mojo/public/cpp/bindings/lib/interface_endpoint_controller.h"
-#include "mojo/public/cpp/bindings/lib/multiplex_router.h"
+#include "mojo/public/cpp/bindings/associated_group_controller.h"
+#include "mojo/public/cpp/bindings/interface_endpoint_controller.h"
 #include "mojo/public/cpp/bindings/sync_call_restrictions.h"
 
 namespace mojo {
-namespace internal {
 
 // ----------------------------------------------------------------------------
 
 namespace {
 
 void DCheckIfInvalid(const base::WeakPtr<InterfaceEndpointClient>& client,
                    const std::string& message) {
   bool is_valid = client && !client->encountered_error();
   DCHECK(!is_valid) << message;
 }
@@ skipping 30 matching lines @@
             FROM_HERE,
             base::Bind(&InterfaceEndpointClient::RaiseError, endpoint_client_));
       }
     }
   }
 
   // MessageReceiver implementation:
   bool Accept(Message* message) override {
     DCHECK(task_runner_->RunsTasksOnCurrentThread());
     accept_was_invoked_ = true;
-    DCHECK(message->has_flag(kMessageIsResponse));
+    DCHECK(message->has_flag(internal::kMessageIsResponse));
 
     bool result = false;
 
     if (endpoint_client_)
       result = endpoint_client_->Accept(message);
 
     return result;
   }
 
   // MessageReceiverWithStatus implementation:
@@ skipping 59 matching lines @@
       encountered_error_(false),
       task_runner_(std::move(runner)),
       weak_ptr_factory_(this) {
   DCHECK(handle_.is_valid());
   DCHECK(handle_.is_local());
 
   // TODO(yzshen): the way to use validator (or message filter in general)
   // directly is a little awkward.
   payload_validator_->set_sink(&thunk_);
 
-  controller_ =
-      handle_.router()->AttachEndpointClient(handle_, this, task_runner_);
+  controller_ = handle_.group_controller()->AttachEndpointClient(
+      handle_, this, task_runner_);
   if (expect_sync_requests)
     controller_->AllowWokenUpBySyncWatchOnSameThread();
 }
 
 InterfaceEndpointClient::~InterfaceEndpointClient() {
   DCHECK(thread_checker_.CalledOnValidThread());
 
-  handle_.router()->DetachEndpointClient(handle_);
+  handle_.group_controller()->DetachEndpointClient(handle_);
 }
 
 AssociatedGroup* InterfaceEndpointClient::associated_group() {
   if (!associated_group_)
-    associated_group_ = handle_.router()->CreateAssociatedGroup();
+    associated_group_ = handle_.group_controller()->CreateAssociatedGroup();
   return associated_group_.get();
 }
 
 uint32_t InterfaceEndpointClient::interface_id() const {
   DCHECK(thread_checker_.CalledOnValidThread());
   return handle_.id();
 }
 
 ScopedInterfaceEndpointHandle InterfaceEndpointClient::PassHandle() {
   DCHECK(thread_checker_.CalledOnValidThread());
   DCHECK(!has_pending_responders());
 
   if (!handle_.is_valid())
     return ScopedInterfaceEndpointHandle();
 
   controller_ = nullptr;
-  handle_.router()->DetachEndpointClient(handle_);
+  handle_.group_controller()->DetachEndpointClient(handle_);
 
   return std::move(handle_);
 }
 
 void InterfaceEndpointClient::RaiseError() {
   DCHECK(thread_checker_.CalledOnValidThread());
 
-  handle_.router()->RaiseError();
+  handle_.group_controller()->RaiseError();
 }
 
 bool InterfaceEndpointClient::Accept(Message* message) {
   DCHECK(thread_checker_.CalledOnValidThread());
   DCHECK(controller_);
-  DCHECK(!message->has_flag(kMessageExpectsResponse));
+  DCHECK(!message->has_flag(internal::kMessageExpectsResponse));
 
   if (encountered_error_)
     return false;
 
   return controller_->SendMessage(message);
 }
 
 bool InterfaceEndpointClient::AcceptWithResponder(Message* message,
                                                   MessageReceiver* responder) {
   DCHECK(thread_checker_.CalledOnValidThread());
   DCHECK(controller_);
-  DCHECK(message->has_flag(kMessageExpectsResponse));
+  DCHECK(message->has_flag(internal::kMessageExpectsResponse));
 
   if (encountered_error_)
     return false;
 
   // Reserve 0 in case we want it to convey special meaning in the future.
   uint64_t request_id = next_request_id_++;
   if (request_id == 0)
     request_id = next_request_id_++;
 
   message->set_request_id(request_id);
 
-  bool is_sync = message->has_flag(kMessageIsSync);
+  bool is_sync = message->has_flag(internal::kMessageIsSync);
   if (!controller_->SendMessage(message))
     return false;
 
   if (!is_sync) {
     // We assume ownership of |responder|.
     async_responders_[request_id] = base::WrapUnique(responder);
     return true;
   }
 
   SyncCallRestrictions::AssertSyncCallAllowed();
@@ skipping 34 matching lines @@
   if (encountered_error_)
     return;
   encountered_error_ = true;
   if (!error_handler_.is_null())
     error_handler_.Run();
 }
 
 bool InterfaceEndpointClient::HandleValidatedMessage(Message* message) {
   DCHECK_EQ(handle_.id(), message->interface_id());
 
-  if (message->has_flag(kMessageExpectsResponse)) {
+  if (message->has_flag(internal::kMessageExpectsResponse)) {
     if (!incoming_receiver_)
       return false;
 
     MessageReceiverWithStatus* responder =
         new ResponderThunk(weak_ptr_factory_.GetWeakPtr(), task_runner_);
     bool ok = incoming_receiver_->AcceptWithResponder(message, responder);
     if (!ok)
       delete responder;
     return ok;
-  } else if (message->has_flag(kMessageIsResponse)) {
+  } else if (message->has_flag(internal::kMessageIsResponse)) {
     uint64_t request_id = message->request_id();
 
-    if (message->has_flag(kMessageIsSync)) {
+    if (message->has_flag(internal::kMessageIsSync)) {
       auto it = sync_responses_.find(request_id);
       if (it == sync_responses_.end())
         return false;
       it->second->response.reset(new Message());
       message->MoveTo(it->second->response.get());
       *it->second->response_received = true;
       return true;
     }
 
     auto it = async_responders_.find(request_id);
     if (it == async_responders_.end())
       return false;
     std::unique_ptr<MessageReceiver> responder = std::move(it->second);
     async_responders_.erase(it);
     return responder->Accept(message);
   } else {
     if (!incoming_receiver_)
       return false;
 
     return incoming_receiver_->Accept(message);
   }
 }
 
-}  // namespace internal
 }  // namespace mojo