ProcessLaunchInfo: remove Debugger reference

[labath]

Summary

The Debuffer object was being used in "GetListenerForProcess" to provide
a default listener object if one was not specified in the launch_info
object.

Since all the callers of this function immediately passed the result to
Target::CreateProcess, it was easy to move this logic there instead.

This brings us one step closer towards being able to move the LaunchInfo
classes to the Host layer (which is there the launching code that
consumes them lives).

include/lldb/Target/ProcessLaunchInfo.h

public:
 
   // Get and set the actual listener that will be used for the process events
   lldb::ListenerSP GetListener() const { return m_listener_sp; }
 
   void SetListener(const lldb::ListenerSP &listener_sp) {
     m_listener_sp = listener_sp;
   }
 
-  lldb::ListenerSP GetListenerForProcess(Debugger &debugger);
-
   lldb::ListenerSP GetHijackListener() const { return m_hijack_listener_sp; }
 
   void SetHijackListener(const lldb::ListenerSP &listener_sp) {
     m_hijack_listener_sp = listener_sp;
   }
 
   void SetLaunchEventData(const char *data) { m_event_data.assign(data); }
 

include/lldb/Target/Target.h

public:
   /// is called, so this is a good way to see what has been parsed
   /// in a target.
   ///
   /// @param[in] s
   ///     The stream to which to dump the object description.
   //------------------------------------------------------------------
   void Dump(Stream *s, lldb::DescriptionLevel description_level);
 
-  const lldb::ProcessSP &CreateProcess(lldb::ListenerSP listener,
+  // If listener_sp is null, the listener of the owning Debugger object will be
+  // used.
+  const lldb::ProcessSP &CreateProcess(lldb::ListenerSP listener_sp,
                                        llvm::StringRef plugin_name,
                                        const FileSpec *crash_file);
 
   const lldb::ProcessSP &GetProcessSP() const;
 
   bool IsValid() { return m_valid; }
 
   void Destroy();

source/Plugins/Platform/Linux/PlatformLinux.cpp

if (target == nullptr) {
     }
   }
 
   // Mark target as currently selected target.
   debugger.GetTargetList().SetSelectedTarget(target);
 
   // Now create the gdb-remote process.
   LLDB_LOG(log, "having target create process with gdb-remote plugin");
-  process_sp = target->CreateProcess(
-      launch_info.GetListenerForProcess(debugger), "gdb-remote", nullptr);
+  process_sp =
+      target->CreateProcess(launch_info.GetListener(), "gdb-remote", nullptr);
 
   if (!process_sp) {
     error.SetErrorString("CreateProcess() failed for gdb-remote process");
     LLDB_LOG(log, "error: {0}", error);
     return process_sp;
   }
 
   LLDB_LOG(log, "successfully created process");

source/Plugins/Platform/NetBSD/PlatformNetBSD.cpp

if (target == nullptr) {
     }
   }
 
   // Mark target as currently selected target.
   debugger.GetTargetList().SetSelectedTarget(target);
 
   // Now create the gdb-remote process.
   LLDB_LOG(log, "having target create process with gdb-remote plugin");
-  process_sp = target->CreateProcess(
-      launch_info.GetListenerForProcess(debugger), "gdb-remote", nullptr);
+  process_sp =
+      target->CreateProcess(launch_info.GetListener(), "gdb-remote", nullptr);
 
   if (!process_sp) {
     error.SetErrorString("CreateProcess() failed for gdb-remote process");
     LLDB_LOG(log, "error: {0}", error);
     return process_sp;
   }
 
   LLDB_LOG(log, "successfully created process");

source/Plugins/Platform/Windows/PlatformWindows.cpp

ProcessSP PlatformWindows::DebugProcess(ProcessLaunchInfo &launch_info,
   // plugin, and PlatformWindows::DebugProcess is just a pass-through to get to
   // the process plugin.
 
   if (launch_info.GetProcessID() != LLDB_INVALID_PROCESS_ID) {
     // This is a process attach.  Don't need to launch anything.
     ProcessAttachInfo attach_info(launch_info);
     return Attach(attach_info, debugger, target, error);
   } else {
-    ProcessSP process_sp =
-        target->CreateProcess(launch_info.GetListenerForProcess(debugger),
-                              launch_info.GetProcessPluginName(), nullptr);
+    ProcessSP process_sp = target->CreateProcess(
+        launch_info.GetListener(), launch_info.GetProcessPluginName(), nullptr);
 
     // We need to launch and attach to the process.
     launch_info.GetFlags().Set(eLaunchFlagDebug);
     if (process_sp)
       error = process_sp->Launch(launch_info);
 
     return process_sp;
   }

source/Plugins/Platform/gdb-server/PlatformRemoteGDBServer.cpp

if (IsConnected()) {
         } else
           error.Clear();
 
         if (target && error.Success()) {
           debugger.GetTargetList().SetSelectedTarget(target);
 
           // The darwin always currently uses the GDB remote debugger plug-in
           // so even when debugging locally we are debugging remotely!
-          process_sp = target->CreateProcess(
-              launch_info.GetListenerForProcess(debugger), "gdb-remote", NULL);
+          process_sp = target->CreateProcess(launch_info.GetListener(),
+                                             "gdb-remote", NULL);
 
           if (process_sp) {
             error = process_sp->ConnectRemote(nullptr, connect_url.c_str());
             // Retry the connect remote one time...
             if (error.Fail())
               error = process_sp->ConnectRemote(nullptr, connect_url.c_str());
             if (error.Success())
               error = process_sp->Launch(launch_info);

source/Target/ProcessLaunchInfo.cpp

 //===-- ProcessLaunchInfo.cpp -----------------------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #include <climits>
 
-#include "lldb/Core/Debugger.h"
 #include "lldb/Host/Config.h"
 #include "lldb/Host/FileSystem.h"
 #include "lldb/Host/HostInfo.h"
 #include "lldb/Target/FileAction.h"
 #include "lldb/Target/ProcessLaunchInfo.h"
 #include "lldb/Target/Target.h"
 #include "lldb/Utility/Log.h"
 #include "lldb/Utility/StreamString.h"
if (GetFlags().Test(eLaunchFlagLaunchInShell)) {
     } else {
       error.SetErrorString("invalid shell path");
     }
   } else {
     error.SetErrorString("not launching in shell");
   }
   return false;
 }
-
-ListenerSP ProcessLaunchInfo::GetListenerForProcess(Debugger &debugger) {
-  if (m_listener_sp)
-    return m_listener_sp;
-  else
-    return debugger.GetListener();
-}

source/Target/Target.cpp

if (m_process_sp) {
 
     m_process_sp.reset();
   }
 }
 
 const lldb::ProcessSP &Target::CreateProcess(ListenerSP listener_sp,
                                              llvm::StringRef plugin_name,
                                              const FileSpec *crash_file) {
+  if (!listener_sp)
+    listener_sp = GetDebugger().GetListener();
   DeleteCurrentProcess();
   m_process_sp = Process::FindPlugin(shared_from_this(), plugin_name,
                                      listener_sp, crash_file);
   return m_process_sp;
 }
 
 const lldb::ProcessSP &Target::GetProcessSP() const { return m_process_sp; }
 
if (log)
                   "process, getting a process plugin to do this for us.",
                   __FUNCTION__);
 
     if (state == eStateConnected) {
       assert(m_process_sp);
     } else {
       // Use a Process plugin to construct the process.
       const char *plugin_name = launch_info.GetProcessPluginName();
-      CreateProcess(launch_info.GetListenerForProcess(debugger), plugin_name,
-                    nullptr);
+      CreateProcess(launch_info.GetListener(), plugin_name, nullptr);
     }
 
     // Since we didn't have a platform launch the process, launch it here.
     if (m_process_sp)
       error = m_process_sp->Launch(launch_info);
   }
 
   if (!m_process_sp) {