Rename ServiceConnector to InterfaceBinder.

components/html_viewer/html_document_application_delegate.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 "components/html_viewer/html_document_application_delegate.h"
 
 #include <utility>
 
 #include "base/bind.h"
 #include "base/macros.h"
 #include "components/html_viewer/global_state.h"
 #include "components/html_viewer/html_document.h"
+#include "mojo/shell/public/cpp/interface_binder.h"
 #include "mojo/shell/public/cpp/shell_client.h"
 
 namespace html_viewer {
 
-// ServiceConnectorQueue records all incoming service requests and processes
+// InterfaceBinderQueue records all incoming service requests and processes
 // them once PushRequestsTo() is called. This is useful if you need to delay
 // processing incoming service requests.
-class HTMLDocumentApplicationDelegate::ServiceConnectorQueue
-    : public mojo::ServiceConnector {
+class HTMLDocumentApplicationDelegate::InterfaceBinderQueue
+    : public mojo::InterfaceBinder {
  public:
-  ServiceConnectorQueue() {}
-  ~ServiceConnectorQueue() override {}
+  InterfaceBinderQueue() {}
+  ~InterfaceBinderQueue() override {}
 
   void PushRequestsTo(mojo::Connection* connection) {
     ScopedVector<Request> requests;
     requests_.swap(requests);
     for (Request* request : requests) {
       connection->GetLocalServiceProvider()->ConnectToService(
           request->interface_name, std::move(request->handle));
     }
   }
 
  private:
   struct Request {
     std::string interface_name;
     mojo::ScopedMessagePipeHandle handle;
   };
 
-  // mojo::ServiceConnector:
-  void ConnectToService(mojo::Connection* connection,
-                        const std::string& interface_name,
-                        mojo::ScopedMessagePipeHandle handle) override {
+  // mojo::InterfaceBinder:
+  void BindInterface(mojo::Connection* connection,
+                     const std::string& interface_name,
+                     mojo::ScopedMessagePipeHandle handle) override {
     scoped_ptr<Request> request(new Request);
     request->interface_name = interface_name;
     request->handle = std::move(handle);
     requests_.push_back(std::move(request));
   }
 
   ScopedVector<Request> requests_;
 
-  DISALLOW_COPY_AND_ASSIGN(ServiceConnectorQueue);
+  DISALLOW_COPY_AND_ASSIGN(InterfaceBinderQueue);
 };
 
 HTMLDocumentApplicationDelegate::HTMLDocumentApplicationDelegate(
     mojo::ShellClientRequest request,
     mojo::URLResponsePtr response,
     GlobalState* global_state,
     scoped_ptr<mojo::AppRefCount> parent_app_refcount,
     const mojo::Callback<void()>& destruct_callback)
     : app_(this,
            std::move(request),
@@ skipping 48 matching lines @@
     // TODO(yzshen): find out a better approach.
     mojo::URLResponsePtr response(mojo::URLResponse::New());
     response->url = url_;
     response->status_code = 200;
     response->mime_type = "text/html";
     OnResponseReceived(nullptr, mojo::URLLoaderPtr(), connection, nullptr,
                        std::move(response));
   } else {
     // HTMLDocument provides services, but is created asynchronously. Queue up
     // requests until the HTMLDocument is created.
-    scoped_ptr<ServiceConnectorQueue> service_connector_queue(
-        new ServiceConnectorQueue);
-    connection->SetServiceConnector(service_connector_queue.get());
+    scoped_ptr<InterfaceBinderQueue> interface_binder_queue(
+        new InterfaceBinderQueue);
+    connection->SetDefaultInterfaceBinder(interface_binder_queue.get());
 
     mojo::URLLoaderPtr loader;
     url_loader_factory_->CreateURLLoader(GetProxy(&loader));
     mojo::URLRequestPtr request(mojo::URLRequest::New());
     request->url = url_;
     request->auto_follow_redirects = true;
 
     // |loader| will be passed to the OnResponseReceived method through a
     // callback. Because order of evaluation is undefined, a reference to the
     // raw pointer is needed.
     mojo::URLLoader* raw_loader = loader.get();
     // The app needs to stay alive while waiting for the response to be
     // available.
     scoped_ptr<mojo::AppRefCount> app_retainer(app_.CreateAppRefCount());
     raw_loader->Start(
         std::move(request),
         base::Bind(&HTMLDocumentApplicationDelegate::OnResponseReceived,
                    weak_factory_.GetWeakPtr(), base::Passed(&app_retainer),
                    base::Passed(&loader), connection,
-                   base::Passed(&service_connector_queue)));
+                   base::Passed(&interface_binder_queue)));
   }
   return true;
 }
 
 void HTMLDocumentApplicationDelegate::OnHTMLDocumentDeleted2(
     HTMLDocument* document) {
   DCHECK(documents2_.count(document) > 0);
   documents2_.erase(document);
 }
 
 void HTMLDocumentApplicationDelegate::OnResponseReceived(
     scoped_ptr<mojo::AppRefCount> app_refcount,
     mojo::URLLoaderPtr loader,
     mojo::Connection* connection,
-    scoped_ptr<ServiceConnectorQueue> connector_queue,
+    scoped_ptr<InterfaceBinderQueue> binder_queue,
     mojo::URLResponsePtr response) {
   // HTMLDocument is destroyed when the hosting view is destroyed, or
   // explicitly from our destructor.
   HTMLDocument* document = new HTMLDocument(
       &app_, connection, std::move(response), global_state_,
       base::Bind(&HTMLDocumentApplicationDelegate::OnHTMLDocumentDeleted2,
                  base::Unretained(this)),
       html_factory_);
   documents2_.insert(document);
 
-  if (connector_queue) {
-    connector_queue->PushRequestsTo(connection);
-    connection->SetServiceConnector(nullptr);
+  if (binder_queue) {
+    binder_queue->PushRequestsTo(connection);
+    connection->SetDefaultInterfaceBinder(nullptr);
   }
 }
 
 HTMLFrame* HTMLDocumentApplicationDelegate::CreateHTMLFrame(
     HTMLFrame::CreateParams* params) {
   return new HTMLFrame(params);
 }
 
 HTMLWidgetRootLocal* HTMLDocumentApplicationDelegate::CreateHTMLWidgetRootLocal(
     HTMLWidgetRootLocal::CreateParams* params) {
   return new HTMLWidgetRootLocal(params);
 }
 
 }  // namespace html_viewer