Source/WebCore/page/Console.cpp

   1 /*
   2  * Copyright (C) 2007 Apple Inc. All rights reserved.
   3  *
   4  * Redistribution and use in source and binary forms, with or without
   5  * modification, are permitted provided that the following conditions
   6  * are met:
   7  *
   8  * 1.  Redistributions of source code must retain the above copyright
   9  *     notice, this list of conditions and the following disclaimer.
  10  * 2.  Redistributions in binary form must reproduce the above copyright
  11  *     notice, this list of conditions and the following disclaimer in the
  12  *     documentation and/or other materials provided with the distribution.
  13  * 3.  Neither the name of Apple Computer, Inc. ("Apple") nor the names of
  14  *     its contributors may be used to endorse or promote products derived
  15  *     from this software without specific prior written permission.
  16  *
  17  * THIS SOFTWARE IS PROVIDED BY APPLE AND ITS CONTRIBUTORS "AS IS" AND ANY
  18  * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
  19  * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
  20  * DISCLAIMED. IN NO EVENT SHALL APPLE OR ITS CONTRIBUTORS BE LIABLE FOR ANY
  21  * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
  22  * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
  23  * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
  24  * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  25  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
  26  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  27  */
  28
  29 #include "config.h"
  30 #include "Console.h"
  31
  32 #include "Chrome.h"
  33 #include "ChromeClient.h"
  34 #include "Frame.h"
  35 #include "FrameLoader.h"
  36 #include "FrameTree.h"
  37 #include "InspectorConsoleInstrumentation.h"
  38 #include "InspectorController.h"
  39 #include "MemoryInfo.h"
  40 #include "Page.h"
  41 #include "PageGroup.h"
  42 #include "PlatformString.h"
  43 #include "ScriptArguments.h"
  44 #include "ScriptCallStack.h"
  45 #include "ScriptProfile.h"
  46 #include "ScriptProfiler.h"
  47 #include "ScriptValue.h"
  48 #include <stdio.h>
  49 #include <wtf/UnusedParam.h>
  50 #include <wtf/text/CString.h>
  51
  52 #if PLATFORM(CHROMIUM)
  53 #include "TraceEvent.h"
  54 #endif
  55
  56 namespace WebCore {
  57
  58 Console::Console(Frame* frame)
  59     : m_frame(frame)
  60 {
  61 }
  62
  63 Console::~Console()
  64 {
  65 }
  66
  67 Frame* Console::frame() const
  68 {
  69     return m_frame;
  70 }
  71
  72 void Console::disconnectFrame()
  73 {
  74     if (m_memory)
  75         m_memory = 0;
  76     m_frame = 0;
  77 }
  78
  79 static void printSourceURLAndLine(const String& sourceURL, unsigned lineNumber)
  80 {
  81     if (!sourceURL.isEmpty()) {
  82         if (lineNumber > 0)
  83             printf("%s:%d: ", sourceURL.utf8().data(), lineNumber);
  84         else
  85             printf("%s: ", sourceURL.utf8().data());
  86     }
  87 }
  88
  89 static void printMessageSourceAndLevelPrefix(MessageSource source, MessageLevel level)
  90 {
  91     const char* sourceString;
  92     switch (source) {
  93     case HTMLMessageSource:
  94         sourceString = "HTML";
  95         break;
  96     case XMLMessageSource:
  97         sourceString = "XML";
  98         break;
  99     case JSMessageSource:
 100         sourceString = "JS";
 101         break;
 102     case NetworkMessageSource:
 103         sourceString = "NETWORK";
 104         break;
 105     case ConsoleAPIMessageSource:
 106         sourceString = "CONSOLEAPI";
 107         break;
 108     case OtherMessageSource:
 109         sourceString = "OTHER";
 110         break;
 111     default:
 112         ASSERT_NOT_REACHED();
 113         sourceString = "UNKNOWN";
 114         break;
 115     }
 116
 117     const char* levelString;
 118     switch (level) {
 119     case TipMessageLevel:
 120         levelString = "TIP";
 121         break;
 122     case LogMessageLevel:
 123         levelString = "LOG";
 124         break;
 125     case WarningMessageLevel:
 126         levelString = "WARN";
 127         break;
 128     case ErrorMessageLevel:
 129         levelString = "ERROR";
 130         break;
 131     case DebugMessageLevel:
 132         levelString = "DEBUG";
 133         break;
 134     default:
 135         ASSERT_NOT_REACHED();
 136         levelString = "UNKNOWN";
 137         break;
 138     }
 139
 140     printf("%s %s:", sourceString, levelString);
 141 }
 142
 143 void Console::addMessage(MessageSource source, MessageType type, MessageLevel level, const String& message, unsigned lineNumber, const String& sourceURL)
 144 {
 145     addMessage(source, type, level, message, lineNumber, sourceURL, 0);
 146 }
 147
 148 void Console::addMessage(MessageSource source, MessageType type, MessageLevel level, const String& message, unsigned lineNumber, const String& sourceURL, PassRefPtr<ScriptCallStack> callStack)
 149 {
 150     Page* page = this->page();
 151     if (!page)
 152         return;
 153
 154     page->chrome()->client()->addMessageToConsole(source, type, level, message, lineNumber, sourceURL);
 155
 156     if (callStack)
 157         InspectorInstrumentation::addMessageToConsole(page, source, type, level, message, 0, callStack);
 158     else
 159         InspectorInstrumentation::addMessageToConsole(page, source, type, level, message, lineNumber, sourceURL);
 160
 161     if (!Console::shouldPrintExceptions())
 162         return;
 163
 164     printSourceURLAndLine(sourceURL, lineNumber);
 165     printMessageSourceAndLevelPrefix(source, level);
 166
 167     printf(" %s\n", message.utf8().data());
 168 }
 169
 170 void Console::addMessage(MessageType type, MessageLevel level, PassRefPtr<ScriptArguments> prpArguments,  PassRefPtr<ScriptCallStack> prpCallStack, bool acceptNoArguments)
 171 {
 172     RefPtr<ScriptArguments> arguments = prpArguments;
 173     RefPtr<ScriptCallStack> callStack = prpCallStack;
 174
 175     Page* page = this->page();
 176     if (!page)
 177         return;
 178
 179     const ScriptCallFrame& lastCaller = callStack->at(0);
 180
 181     if (!acceptNoArguments && !arguments->argumentCount())
 182         return;
 183
 184     if (Console::shouldPrintExceptions()) {
 185         printSourceURLAndLine(lastCaller.sourceURL(), 0);
 186         printMessageSourceAndLevelPrefix(ConsoleAPIMessageSource, level);
 187
 188         for (unsigned i = 0; i < arguments->argumentCount(); ++i) {
 189             String argAsString;
 190             if (arguments->argumentAt(i).getString(arguments->globalState(), argAsString))
 191                 printf(" %s", argAsString.utf8().data());
 192         }
 193         printf("\n");
 194     }
 195
 196     String message;
 197     if (arguments->getFirstArgumentAsString(message))
 198         page->chrome()->client()->addMessageToConsole(ConsoleAPIMessageSource, type, level, message, lastCaller.lineNumber(), lastCaller.sourceURL());
 199
 200     InspectorInstrumentation::addMessageToConsole(page, ConsoleAPIMessageSource, type, level, message, arguments, callStack);
 201 }
 202
 203 void Console::debug(PassRefPtr<ScriptArguments> arguments, PassRefPtr<ScriptCallStack> callStack)
 204 {
 205     // In Firebug, console.debug has the same behavior as console.log. So we'll do the same.
 206     log(arguments, callStack);
 207 }
 208
 209 void Console::error(PassRefPtr<ScriptArguments> arguments, PassRefPtr<ScriptCallStack> callStack)
 210 {
 211     addMessage(LogMessageType, ErrorMessageLevel, arguments, callStack);
 212 }
 213
 214 void Console::info(PassRefPtr<ScriptArguments> arguments, PassRefPtr<ScriptCallStack> callStack)
 215 {
 216     log(arguments, callStack);
 217 }
 218
 219 void Console::log(PassRefPtr<ScriptArguments> arguments, PassRefPtr<ScriptCallStack> callStack)
 220 {
 221     addMessage(LogMessageType, LogMessageLevel, arguments, callStack);
 222 }
 223
 224 void Console::dir(PassRefPtr<ScriptArguments> arguments, PassRefPtr<ScriptCallStack> callStack)
 225 {
 226     addMessage(DirMessageType, LogMessageLevel, arguments, callStack);
 227 }
 228
 229 void Console::dirxml(PassRefPtr<ScriptArguments> arguments, PassRefPtr<ScriptCallStack> callStack)
 230 {
 231     addMessage(DirXMLMessageType, LogMessageLevel, arguments, callStack);
 232 }
 233
 234 void Console::trace(PassRefPtr<ScriptArguments> arguments, PassRefPtr<ScriptCallStack> prpCallStack)
 235 {
 236     RefPtr<ScriptCallStack> callStack = prpCallStack;
 237     addMessage(TraceMessageType, LogMessageLevel, arguments, callStack, true);
 238
 239     if (!shouldPrintExceptions())
 240         return;
 241
 242     printf("Stack Trace\n");
 243     for (unsigned i = 0; i < callStack->size(); ++i) {
 244         String functionName = String(callStack->at(i).functionName());
 245         printf("\t%s\n", functionName.utf8().data());
 246     }
 247 }
 248
 249 void Console::assertCondition(bool condition, PassRefPtr<ScriptArguments> arguments, PassRefPtr<ScriptCallStack> callStack)
 250 {
 251     if (condition)
 252         return;
 253
 254     addMessage(AssertMessageType, ErrorMessageLevel, arguments, callStack, true);
 255 }
 256
 257 void Console::count(PassRefPtr<ScriptArguments> arguments, PassRefPtr<ScriptCallStack> callStack)
 258 {
 259     InspectorInstrumentation::consoleCount(page(), arguments, callStack);
 260 }
 261
 262 void Console::markTimeline(PassRefPtr<ScriptArguments> arguments, PassRefPtr<ScriptCallStack>)
 263 {
 264     InspectorInstrumentation::consoleTimeStamp(page(), arguments);
 265 }
 266
 267 #if ENABLE(JAVASCRIPT_DEBUGGER)
 268
 269 void Console::profile(const String& title, ScriptState* state, PassRefPtr<ScriptCallStack> callStack)
 270 {
 271     Page* page = this->page();
 272     if (!page)
 273         return;
 274
 275     // FIXME: log a console message when profiling is disabled.
 276     if (!InspectorInstrumentation::profilerEnabled(page))
 277         return;
 278
 279     String resolvedTitle = title;
 280     if (title.isNull()) // no title so give it the next user initiated profile title.
 281         resolvedTitle = InspectorInstrumentation::getCurrentUserInitiatedProfileName(page, true);
 282
 283     ScriptProfiler::start(state, resolvedTitle);
 284
 285     const ScriptCallFrame& lastCaller = callStack->at(0);
 286     InspectorInstrumentation::addStartProfilingMessageToConsole(page, resolvedTitle, lastCaller.lineNumber(), lastCaller.sourceURL());
 287 }
 288
 289 void Console::profileEnd(const String& title, ScriptState* state, PassRefPtr<ScriptCallStack> callStack)
 290 {
 291     Page* page = this->page();
 292     if (!page)
 293         return;
 294
 295     if (!InspectorInstrumentation::profilerEnabled(page))
 296         return;
 297
 298     RefPtr<ScriptProfile> profile = ScriptProfiler::stop(state, title);
 299     if (!profile)
 300         return;
 301
 302     m_profiles.append(profile);
 303     InspectorInstrumentation::addProfile(page, profile, callStack);
 304 }
 305
 306 #endif
 307
 308 void Console::time(const String& title)
 309 {
 310     InspectorInstrumentation::startConsoleTiming(page(), title);
 311 #if PLATFORM(CHROMIUM)
 312     if (PlatformSupport::isTraceEventEnabled())
 313         PlatformSupport::traceEventBegin(title.utf8().data(), 0, 0);
 314 #endif
 315 }
 316
 317 void Console::timeEnd(const String& title, PassRefPtr<ScriptArguments>, PassRefPtr<ScriptCallStack> callStack)
 318 {
 319 #if PLATFORM(CHROMIUM)
 320     if (PlatformSupport::isTraceEventEnabled())
 321         PlatformSupport::traceEventEnd(title.utf8().data(), 0, 0);
 322 #endif
 323     InspectorInstrumentation::stopConsoleTiming(page(), title, callStack);
 324 }
 325
 326 void Console::timeStamp(PassRefPtr<ScriptArguments> arguments, PassRefPtr<ScriptCallStack>)
 327 {
 328     InspectorInstrumentation::consoleTimeStamp(page(), arguments);
 329 }
 330
 331 void Console::group(PassRefPtr<ScriptArguments> arguments, PassRefPtr<ScriptCallStack> callStack)
 332 {
 333     InspectorInstrumentation::addMessageToConsole(page(), ConsoleAPIMessageSource, StartGroupMessageType, LogMessageLevel, String(), arguments, callStack);
 334 }
 335
 336 void Console::groupCollapsed(PassRefPtr<ScriptArguments> arguments, PassRefPtr<ScriptCallStack> callStack)
 337 {
 338     InspectorInstrumentation::addMessageToConsole(page(), ConsoleAPIMessageSource, StartGroupCollapsedMessageType, LogMessageLevel, String(), arguments, callStack);
 339 }
 340
 341 void Console::groupEnd()
 342 {
 343     InspectorInstrumentation::addMessageToConsole(page(), ConsoleAPIMessageSource, EndGroupMessageType, LogMessageLevel, String(), 0, String());
 344 }
 345
 346 bool Console::shouldCaptureFullStackTrace() const
 347 {
 348 #if ENABLE(INSPECTOR)
 349     Page* page = this->page();
 350     if (!page)
 351         return false;
 352
 353     return page->inspectorController()->hasFrontend();
 354 #else
 355     return false;
 356 #endif
 357 }
 358
 359 void Console::warn(PassRefPtr<ScriptArguments> arguments, PassRefPtr<ScriptCallStack> callStack)
 360 {
 361     addMessage(LogMessageType, WarningMessageLevel, arguments, callStack);
 362 }
 363
 364 MemoryInfo* Console::memory() const
 365 {
 366     m_memory = MemoryInfo::create(m_frame);
 367     return m_memory.get();
 368 }
 369
 370 static bool printExceptions = false;
 371
 372 bool Console::shouldPrintExceptions()
 373 {
 374     return printExceptions;
 375 }
 376
 377 void Console::setShouldPrintExceptions(bool print)
 378 {
 379     printExceptions = print;
 380 }
 381
 382 Page* Console::page() const
 383 {
 384     if (!m_frame)
 385         return 0;
 386     return m_frame->page();
 387 }
 388
 389 } // namespace WebCore