Remove the callback-based log channel registration mechanism

[labath]

Summary

All the existing channels have beens switched to the new mechanism and
this code is now unused.

include/lldb/Core/Log.h

 //===-- Log.h ---------------------------------------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef liblldb_Log_h_
 #define liblldb_Log_h_
 
 // Project includes
 #include "lldb/Core/Logging.h"
-#include "lldb/Utility/ConstString.h"
 #include "lldb/Utility/Flags.h"
 #include "lldb/lldb-private.h"
 
 // Other libraries and framework includes
 #include "llvm/Support/FormatVariadic.h"
 #include "llvm/Support/RWMutex.h"
 // C++ Includes
 #include <atomic>
public:
     void Enable(Log &log, const std::shared_ptr<llvm::raw_ostream> &stream_sp,
                 uint32_t flags);
 
     // Calls to Enable and disable need to be serialized externally.
     void Disable(uint32_t flags);
   };
 
   //------------------------------------------------------------------
-  // Callback definitions for abstracted plug-in log access.
-  //------------------------------------------------------------------
-  typedef void (*DisableCallback)(const char **categories,
-                                  Stream *feedback_strm);
-  typedef Log *(*EnableCallback)(
-      const std::shared_ptr<llvm::raw_ostream> &log_stream_sp,
-      uint32_t log_options, const char **categories, Stream *feedback_strm);
-  typedef void (*ListCategoriesCallback)(Stream *strm);
-
-  struct Callbacks {
-    DisableCallback disable;
-    EnableCallback enable;
-    ListCategoriesCallback list_categories;
-  };
-
-  //------------------------------------------------------------------
   // Static accessors for logging channels
   //------------------------------------------------------------------
   static void Register(llvm::StringRef name, Channel &channel);
   static void Unregister(llvm::StringRef name);
 
-  static void RegisterLogChannel(const ConstString &channel,
-                                 const Log::Callbacks &log_callbacks);
-
-  static bool UnregisterLogChannel(const ConstString &channel);
-
-  static bool GetLogChannelCallbacks(const ConstString &channel,
-                                     Log::Callbacks &log_callbacks);
-
   static bool
   EnableLogChannel(const std::shared_ptr<llvm::raw_ostream> &log_stream_sp,
                    uint32_t log_options, llvm::StringRef channel,
                    const char **categories, Stream &error_stream);
 
   static bool DisableLogChannel(llvm::StringRef channel,
                                 const char **categories, Stream &error_stream);
 

source/API/SBCommandReturnObject.cpp

 // Other libraries and framework includes
 // Project includes
 #include "lldb/API/SBCommandReturnObject.h"
 #include "lldb/API/SBError.h"
 #include "lldb/API/SBStream.h"
 
 #include "lldb/Core/Log.h"
 #include "lldb/Interpreter/CommandReturnObject.h"
+#include "lldb/Utility/ConstString.h"
 #include "lldb/Utility/Error.h"
 
 using namespace lldb;
 using namespace lldb_private;
 
 SBCommandReturnObject::SBCommandReturnObject()
     : m_opaque_ap(new CommandReturnObject()) {}
 

source/Core/Log.cpp

void Log::Warning(const char *format, ...) {
 
   if (arg_msg == nullptr)
     return;
 
   Printf("warning: %s", arg_msg);
   free(arg_msg);
 }
 
-typedef std::map<ConstString, Log::Callbacks> CallbackMap;
-typedef CallbackMap::iterator CallbackMapIter;
-
-// Surround our callback map with a singleton function so we don't have any
-// global initializers.
-static CallbackMap &GetCallbackMap() {
-  static CallbackMap g_callback_map;
-  return g_callback_map;
-}
-
 void Log::Register(llvm::StringRef name, Channel &channel) {
   auto iter = g_channel_map->try_emplace(name, channel);
   assert(iter.second == true);
   (void)iter;
 }
 
 void Log::Unregister(llvm::StringRef name) {
   auto iter = g_channel_map->find(name);
   assert(iter != g_channel_map->end());
   iter->second.channel.Disable(UINT32_MAX);
   g_channel_map->erase(iter);
 }
 
-void Log::RegisterLogChannel(const ConstString &channel,
-                             const Log::Callbacks &log_callbacks) {
-  GetCallbackMap().insert(std::make_pair(channel, log_callbacks));
-}
-
-bool Log::UnregisterLogChannel(const ConstString &channel) {
-  return GetCallbackMap().erase(channel) != 0;
-}
-
-bool Log::GetLogChannelCallbacks(const ConstString &channel,
-                                 Log::Callbacks &log_callbacks) {
-  CallbackMap &callback_map = GetCallbackMap();
-  CallbackMapIter pos = callback_map.find(channel);
-  if (pos != callback_map.end()) {
-    log_callbacks = pos->second;
-    return true;
-  }
-  ::memset(&log_callbacks, 0, sizeof(log_callbacks));
-  return false;
-}
-
 bool Log::EnableLogChannel(
     const std::shared_ptr<llvm::raw_ostream> &log_stream_sp,
     uint32_t log_options, llvm::StringRef channel, const char **categories,
     Stream &error_stream) {
-  Log::Callbacks log_callbacks;
-  if (Log::GetLogChannelCallbacks(ConstString(channel), log_callbacks)) {
-    log_callbacks.enable(log_stream_sp, log_options, categories, &error_stream);
-    return true;
-  }
-
   auto iter = g_channel_map->find(channel);
   if (iter == g_channel_map->end()) {
     error_stream.Format("Invalid log channel '{0}'.\n", channel);
     return false;
   }
   uint32_t flags = categories && categories[0]
                        ? GetFlags(error_stream, *iter, categories)
                        : iter->second.channel.default_flags;
   iter->second.channel.Enable(iter->second.log, log_stream_sp, flags);
   return true;
 }
 
 bool Log::DisableLogChannel(llvm::StringRef channel, const char **categories,
                             Stream &error_stream) {
-  Log::Callbacks log_callbacks;
-  if (Log::GetLogChannelCallbacks(ConstString(channel), log_callbacks)) {
-    log_callbacks.disable(categories, &error_stream);
-    return true;
-  }
-
   auto iter = g_channel_map->find(channel);
   if (iter == g_channel_map->end()) {
     error_stream.Format("Invalid log channel '{0}'.\n", channel);
     return false;
   }
   uint32_t flags = categories && categories[0]
                        ? GetFlags(error_stream, *iter, categories)
                        : UINT32_MAX;
   iter->second.channel.Disable(flags);
   return true;
 }
 
 bool Log::ListChannelCategories(llvm::StringRef channel, Stream &stream) {
-  Log::Callbacks log_callbacks;
-  if (Log::GetLogChannelCallbacks(ConstString(channel), log_callbacks)) {
-    log_callbacks.list_categories(&stream);
-    return true;
-  }
-
   auto ch = g_channel_map->find(channel);
   if (ch == g_channel_map->end()) {
     stream.Format("Invalid log channel '{0}'.\n", channel);
     return false;
   }
   ListCategories(stream, *ch);
   return true;
 }
 
 void Log::DisableAllLogChannels(Stream *feedback_strm) {
-  CallbackMap &callback_map = GetCallbackMap();
-  CallbackMapIter pos, end = callback_map.end();
-  const char *categories[] = {"all", nullptr};
-
-  for (pos = callback_map.begin(); pos != end; ++pos)
-    pos->second.disable(categories, feedback_strm);
-
   for (auto &entry : *g_channel_map)
     entry.second.channel.Disable(UINT32_MAX);
 }
 
 void Log::ListAllLogChannels(Stream *strm) {
-  CallbackMap &callback_map = GetCallbackMap();
-
-  if (callback_map.empty() && g_channel_map->empty()) {
+  if (g_channel_map->empty()) {
     strm->PutCString("No logging channels are currently registered.\n");
     return;
   }
 
-  CallbackMapIter pos, end = callback_map.end();
-  for (pos = callback_map.begin(); pos != end; ++pos)
-    pos->second.list_categories(strm);
-
   for (const auto &channel : *g_channel_map)
     ListCategories(*strm, channel);
 }
 bool Log::GetVerbose() const { return m_options.Test(LLDB_LOG_OPTION_VERBOSE); }
 
 void Log::WriteHeader(llvm::raw_ostream &OS, llvm::StringRef file,
                       llvm::StringRef function) {
   static uint32_t g_sequence_id = 0;