DevTools: Remove base/ dependencies from glue/devtools

webkit/glue/devtools/debugger_agent_manager.cc

 // Copyright (c) 2009 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 "config.h"
 
 #include "Frame.h"
 #include "PageGroupLoadDeferrer.h"
 #include "V8Proxy.h"
 #include <wtf/HashSet.h>
 #undef LOG
 
-#include "base/string_util.h"
 #include "webkit/api/public/WebDevToolsAgent.h"
 #include "webkit/glue/devtools/debugger_agent_impl.h"
 #include "webkit/glue/devtools/debugger_agent_manager.h"
 #include "webkit/glue/webdevtoolsagent_impl.h"
 #include "webkit/glue/webview_impl.h"
 
 #if USE(V8)
 #include "v8/include/v8-debug.h"
 #endif
 
@@ skipping 86 matching lines @@
 
 // static
 void DebuggerAgentManager::DebugAttach(DebuggerAgentImpl* debugger_agent) {
   if (!attached_agents_map_) {
     attached_agents_map_ = new AttachedAgentsMap();
     v8::Debug::SetMessageHandler2(&DebuggerAgentManager::OnV8DebugMessage);
     v8::Debug::SetHostDispatchHandler(
         &DebuggerAgentManager::V8DebugHostDispatchHandler, 100 /* ms */);
   }
   int host_id = debugger_agent->webdevtools_agent()->host_id();
-  DCHECK(host_id != 0);
+  ASSERT(host_id != 0);
   attached_agents_map_->set(host_id, debugger_agent);
 }
 
 // static
 void DebuggerAgentManager::DebugDetach(DebuggerAgentImpl* debugger_agent) {
   if (!attached_agents_map_) {
-    NOTREACHED();
+    ASSERT_NOT_REACHED();
     return;
   }
   int host_id = debugger_agent->webdevtools_agent()->host_id();
-  DCHECK(attached_agents_map_->get(host_id) == debugger_agent);
+  ASSERT(attached_agents_map_->get(host_id) == debugger_agent);
   bool is_on_breakpoint = (FindAgentForCurrentV8Context() == debugger_agent);
   attached_agents_map_->remove(host_id);
 
   if (attached_agents_map_->isEmpty()) {
     delete attached_agents_map_;
     attached_agents_map_ = NULL;
     // Note that we do not empty handlers while in dispatch - we schedule
     // continue and do removal once we are out of the dispatch. Also there is
     // no need to send continue command in this case since removing message
     // handler will cause debugger unload and all breakpoints will be cleared.
@@ skipping 14 matching lines @@
       // debugger was paused on a breakpoint(as long as there are other
       // attached agents v8 will wait for explicit'continue' message).
       SendContinueCommandToV8();
     }
   }
 }
 
 // static
 void DebuggerAgentManager::DebugBreak(DebuggerAgentImpl* debugger_agent) {
 #if USE(V8)
-  DCHECK(DebuggerAgentForHostId(debugger_agent->webdevtools_agent()->host_id())
+  ASSERT(DebuggerAgentForHostId(debugger_agent->webdevtools_agent()->host_id())
              == debugger_agent);
   if (in_utility_context_) {
     debug_break_delayed_ = true;
   } else {
     v8::Debug::DebugBreak();
   }
 #endif
 }
 
 // static
@@ skipping 12 matching lines @@
     DebuggerAgentImpl* debugger_agent =
         DebuggerAgentForHostId(wrapper->caller_id());
     if (debugger_agent) {
       debugger_agent->DebuggerOutput(out);
     } else if (!message.WillStartRunning()) {
       // Autocontinue execution if there is no handler.
       SendContinueCommandToV8();
     }
     return;
   } // Otherwise it's an event message.
-  DCHECK(message.IsEvent());
+  ASSERT(message.IsEvent());
 
   // Ignore unsupported event types.
   if (message.GetEvent() != v8::AfterCompile &&
       message.GetEvent() != v8::Break &&
       message.GetEvent() != v8::Exception) {
     return;
   }
 
   v8::Handle<v8::Context> context = message.GetEventContext();
   // If the context is from one of the inpected tabs it should have its context
@@ skipping 37 matching lines @@
 }
 
 // static
 void DebuggerAgentManager::SetMessageLoopDispatchHandler(
     WebDevToolsAgent::MessageLoopDispatchHandler handler) {
   message_loop_dispatch_handler_ = handler;
 }
 
 // static
 void DebuggerAgentManager::SetHostId(WebFrameImpl* webframe, int host_id) {
-  DCHECK(host_id > 0);
+  ASSERT(host_id > 0);
   WebCore::V8Proxy* proxy = WebCore::V8Proxy::retrieve(webframe->frame());
   if (proxy) {
     proxy->setContextDebugId(host_id);
   }
 }
 
 // static
 void DebuggerAgentManager::OnWebViewClosed(WebViewImpl* webview) {
   if (page_deferrers_.contains(webview)) {
     delete page_deferrers_.get(webview);
@@ skipping 22 matching lines @@
   String continue_cmd(
       "{\"seq\":1,\"type\":\"request\",\"command\":\"continue\"}");
   SendCommandToV8(continue_cmd, new CallerIdWrapper());
 }
 
 // static
 DebuggerAgentImpl* DebuggerAgentManager::FindAgentForCurrentV8Context() {
   if (!attached_agents_map_) {
     return NULL;
   }
-  DCHECK(!attached_agents_map_->isEmpty());
+  ASSERT(!attached_agents_map_->isEmpty());
 
   WebCore::Frame* frame = WebCore::V8Proxy::retrieveFrameForEnteredContext();
   if (!frame) {
     return NULL;
   }
   WebCore::Page* page = frame->page();
   for (AttachedAgentsMap::iterator it = attached_agents_map_->begin();
        it != attached_agents_map_->end(); ++it) {
     if (it->second->GetPage() == page) {
       return it->second;
     }
   }
   return NULL;
 }
 
 // static
 DebuggerAgentImpl* DebuggerAgentManager::DebuggerAgentForHostId(int host_id) {
   if (!attached_agents_map_) {
     return NULL;
   }
   return attached_agents_map_->get(host_id);
 }