Use a weak pointer to post service control events and session change notifications.

remoting/host/daemon_process_win.cc

 // Copyright (c) 2012 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 "remoting/host/daemon_process.h"
 
 #include "base/base_switches.h"
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/location.h"
@@ skipping 42 matching lines @@
   virtual void OnChannelConnected(int32 peer_pid) OVERRIDE;
 
   // DaemonProcess overrides.
   virtual void SendToNetwork(IPC::Message* message) OVERRIDE;
   virtual bool OnDesktopSessionAgentAttached(
       int terminal_id,
       base::ProcessHandle desktop_process,
       IPC::PlatformFileForTransit desktop_pipe) OVERRIDE;
 
  protected:
-  // Stoppable implementation.
-  virtual void DoStop() OVERRIDE;
-
   // DaemonProcess implementation.
   virtual scoped_ptr<DesktopSession> DoCreateDesktopSession(
       int terminal_id,
       const ScreenResolution& resolution,
       bool virtual_terminal) OVERRIDE;
   virtual void DoCrashNetworkProcess(
       const tracked_objects::Location& location) OVERRIDE;
   virtual void LaunchNetworkProcess() OVERRIDE;
 
  private:
   scoped_ptr<WorkerProcessLauncher> network_launcher_;
 
   // Handle of the network process.
   ScopedHandle network_process_;
 
   DISALLOW_COPY_AND_ASSIGN(DaemonProcessWin);
 };
 
 DaemonProcessWin::DaemonProcessWin(
     scoped_refptr<AutoThreadTaskRunner> caller_task_runner,
     scoped_refptr<AutoThreadTaskRunner> io_task_runner,
     const base::Closure& stopped_callback)
     : DaemonProcess(caller_task_runner, io_task_runner, stopped_callback) {
 }
 
 DaemonProcessWin::~DaemonProcessWin() {
-  // Make sure that the object is completely stopped. The same check exists
-  // in Stoppable::~Stoppable() but this one helps us to fail early and
-  // predictably.
-  CHECK_EQ(stoppable_state(), Stoppable::kStopped);
 }
 
 void DaemonProcessWin::OnChannelConnected(int32 peer_pid) {
   // Obtain the handle of the network process.
   network_process_.Set(OpenProcess(PROCESS_DUP_HANDLE, false, peer_pid));
   if (!network_process_.IsValid()) {
     CrashNetworkProcess(FROM_HERE);
     return;
   }
 
@@ skipping 25 matching lines @@
     return false;
   }
 
   // |desktop_pipe| is a handle in the desktop process. It will be duplicated
   // by the network process directly from the desktop process.
   SendToNetwork(new ChromotingDaemonNetworkMsg_DesktopAttached(
       terminal_id, desktop_process_for_transit, desktop_pipe));
   return true;
 }
 
-void DaemonProcessWin::DoStop() {
-  DCHECK(caller_task_runner()->BelongsToCurrentThread());
-
-  network_launcher_.reset();
-  DaemonProcess::DoStop();
-}
-
 scoped_ptr<DesktopSession> DaemonProcessWin::DoCreateDesktopSession(
     int terminal_id,
     const ScreenResolution& resolution,
     bool virtual_terminal) {
   DCHECK(caller_task_runner()->BelongsToCurrentThread());
 
   if (virtual_terminal) {
     return DesktopSessionWin::CreateForVirtualTerminal(
         caller_task_runner(), io_task_runner(), this, terminal_id, resolution);
   } else {
@@ skipping 36 matching lines @@
     scoped_refptr<AutoThreadTaskRunner> io_task_runner,
     const base::Closure& stopped_callback) {
   scoped_ptr<DaemonProcessWin> daemon_process(
       new DaemonProcessWin(caller_task_runner, io_task_runner,
                            stopped_callback));
   daemon_process->Initialize();
   return daemon_process.PassAs<DaemonProcess>();
 }
 
 }  // namespace remoting