Add SetClient method implementation to InterfaceImpl.

mojo/shell/app_child_process.cc

 // Copyright 2014 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/shell/app_child_process.h"
 
 #include "base/bind.h"
 #include "base/callback_helpers.h"
 #include "base/file_util.h"
 #include "base/files/file_path.h"
@@ skipping 141 matching lines @@
 };
 
 // AppChildControllerImpl ------------------------------------------------------
 
 class AppChildControllerImpl : public InterfaceImpl<AppChildController> {
  public:
   virtual ~AppChildControllerImpl() {
     DCHECK(thread_checker_.CalledOnValidThread());
 
     // TODO(vtl): Pass in the result from |MainMain()|.
-    if (controller_client_)
-      controller_client_->AppCompleted(MOJO_RESULT_UNIMPLEMENTED);
+    client()->AppCompleted(MOJO_RESULT_UNIMPLEMENTED);
   }
 
   // To be executed on the controller thread. Creates the |AppChildController|,
   // etc.
   static void Init(
       AppContext* app_context,
       embedder::ScopedPlatformHandle platform_channel,
       const Blocker::Unblocker& unblocker) {
     DCHECK(app_context);
     DCHECK(platform_channel.is_valid());
@@ skipping 13 matching lines @@
     BindToPipe(impl.get(), host_message_pipe.Pass());
 
     app_context->set_controller(impl.Pass());
   }
 
   virtual void OnConnectionError() OVERRIDE {
     // TODO(darin): How should we handle a connection error here?
   }
 
   // |AppChildController| methods:
-
-  virtual void SetClient(AppChildControllerClient* client) OVERRIDE {
-    controller_client_ = client;
-  }
-
   virtual void StartApp(const String& app_path,
                         ScopedMessagePipeHandle service) OVERRIDE {
     DVLOG(2) << "AppChildControllerImpl::StartApp("
              << app_path.To<std::string>() << ", ...)";
     DCHECK(thread_checker_.CalledOnValidThread());
 
     // TODO(darin): Add TypeConverter for FilePath <-> mojo::String.
     unblocker_.Unblock(base::Bind(&AppChildControllerImpl::StartAppOnMainThread,
                                   base::FilePath::FromUTF8Unsafe(
                                       app_path.To<std::string>()),
                                   base::Passed(&service)));
   }
 
  private:
   AppChildControllerImpl(AppContext* app_context,
                          const Blocker::Unblocker& unblocker)
       : app_context_(app_context),
         unblocker_(unblocker),
-        controller_client_(NULL),
         channel_info_(NULL) {
   }
 
   // Callback for |embedder::CreateChannel()|.
   void DidCreateChannel(embedder::ChannelInfo* channel_info) {
     DVLOG(2) << "AppChildControllerImpl::DidCreateChannel()";
     DCHECK(thread_checker_.CalledOnValidThread());
     channel_info_ = channel_info;
   }
 
@@ skipping 29 matching lines @@
       MojoResult result = main_function(service.release().value());
       if (result < MOJO_RESULT_OK)
         LOG(ERROR) << "MojoMain returned an error: " << result;
     } while (false);
   }
 
   base::ThreadChecker thread_checker_;
   AppContext* const app_context_;
   Blocker::Unblocker unblocker_;
 
-  AppChildControllerClient* controller_client_;
   embedder::ChannelInfo* channel_info_;
 
   DISALLOW_COPY_AND_ASSIGN(AppChildControllerImpl);
 };
 
 }  // namespace
 
 // AppChildProcess -------------------------------------------------------------
 
 AppChildProcess::AppChildProcess() {
@@ skipping 14 matching lines @@
       base::Bind(&AppChildControllerImpl::Init, base::Unretained(&app_context),
                  base::Passed(platform_channel()), blocker.GetUnblocker()));
   // This will block, then run whatever the controller wants.
   blocker.Block();
 
   app_context.Shutdown();
 }
 
 }  // namespace shell
 }  // namespace mojo