Report Javascript Runtime Errors to the Error Console

chrome/renderer/chrome_render_view_observer.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 "chrome/renderer/chrome_render_view_observer.h"
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/command_line.h"
 #include "base/debug/trace_event.h"
 #include "base/message_loop/message_loop.h"
 #include "base/metrics/histogram.h"
+#include "base/strings/string_split.h"
 #include "base/strings/utf_string_conversions.h"
 #include "chrome/common/chrome_constants.h"
 #include "chrome/common/chrome_switches.h"
 #include "chrome/common/prerender_messages.h"
 #include "chrome/common/render_messages.h"
 #include "chrome/common/url_constants.h"
 #include "chrome/renderer/chrome_render_process_observer.h"
 #include "chrome/renderer/content_settings_observer.h"
 #include "chrome/renderer/extensions/dispatcher.h"
 #include "chrome/renderer/external_host_bindings.h"
 #include "chrome/renderer/frame_sniffer.h"
 #include "chrome/renderer/prerender/prerender_helper.h"
 #include "chrome/renderer/safe_browsing/phishing_classifier_delegate.h"
 #include "chrome/renderer/translate/translate_helper.h"
 #include "chrome/renderer/webview_color_overlay.h"
 #include "content/public/common/bindings_policy.h"
 #include "content/public/renderer/content_renderer_client.h"
 #include "content/public/renderer/render_view.h"
 #include "extensions/common/constants.h"
+#include "extensions/common/stack_frame.h"
 #include "net/base/data_url.h"
 #include "skia/ext/image_operations.h"
 #include "skia/ext/platform_canvas.h"
 #include "third_party/WebKit/public/platform/WebCString.h"
 #include "third_party/WebKit/public/platform/WebRect.h"
 #include "third_party/WebKit/public/platform/WebSize.h"
 #include "third_party/WebKit/public/platform/WebString.h"
 #include "third_party/WebKit/public/platform/WebURLRequest.h"
 #include "third_party/WebKit/public/platform/WebVector.h"
 #include "third_party/WebKit/public/web/WebAccessibilityObject.h"
 #include "third_party/WebKit/public/web/WebDataSource.h"
 #include "third_party/WebKit/public/web/WebDocument.h"
 #include "third_party/WebKit/public/web/WebElement.h"
 #include "third_party/WebKit/public/web/WebFrame.h"
 #include "third_party/WebKit/public/web/WebInputEvent.h"
 #include "third_party/WebKit/public/web/WebNode.h"
 #include "third_party/WebKit/public/web/WebNodeList.h"
 #include "third_party/WebKit/public/web/WebView.h"
 #include "ui/base/ui_base_switches_util.h"
 #include "ui/gfx/favicon_size.h"
 #include "ui/gfx/size.h"
 #include "ui/gfx/size_f.h"
 #include "ui/gfx/skbitmap_operations.h"
 #include "v8/include/v8-testing.h"
 #include "webkit/glue/webkit_glue.h"
 
+using base::string16;
+using extensions::APIPermission;
 using WebKit::WebAccessibilityObject;
 using WebKit::WebCString;
 using WebKit::WebDataSource;
 using WebKit::WebDocument;
 using WebKit::WebElement;
 using WebKit::WebFrame;
 using WebKit::WebGestureEvent;
 using WebKit::WebIconURL;
 using WebKit::WebNode;
 using WebKit::WebNodeList;
 using WebKit::WebRect;
 using WebKit::WebSecurityOrigin;
 using WebKit::WebSize;
 using WebKit::WebString;
 using WebKit::WebTouchEvent;
 using WebKit::WebURL;
 using WebKit::WebURLRequest;
 using WebKit::WebView;
 using WebKit::WebVector;
 using WebKit::WebWindowFeatures;
-using extensions::APIPermission;
 
 // Delay in milliseconds that we'll wait before capturing the page contents
 // and thumbnail.
 static const int kDelayForCaptureMs = 500;
 
 // Typically, we capture the page data once the page is loaded.
 // Sometimes, the page never finishes to load, preventing the page capture
 // To workaround this problem, we always perform a capture after the following
 // delay.
 static const int kDelayForForcedCaptureMs = 6000;
@@ skipping 70 matching lines @@
 static const char kGoogleDotCom[] = "google.com";
 
 static bool isHostInDomain(const std::string& host, const std::string& domain) {
   return (EndsWith(host, domain, false) &&
           (host.length() == domain.length() ||
            (host.length() > domain.length() &&
             host[host.length() - domain.length() - 1] == '.')));
 }
 
 namespace {
+
 GURL StripRef(const GURL& url) {
   GURL::Replacements replacements;
   replacements.ClearRef();
   return url.ReplaceComponents(replacements);
 }
 
 // If the source image is null or occupies less area than
 // |thumbnail_min_area_pixels|, we return the image unmodified.  Otherwise, we
 // scale down the image so that the width and height do not exceed
 // |thumbnail_max_size_pixels|, preserving the original aspect ratio.
-static SkBitmap Downscale(WebKit::WebImage image,
-                          int thumbnail_min_area_pixels,
-                          gfx::Size thumbnail_max_size_pixels) {
+SkBitmap Downscale(WebKit::WebImage image,
+                   int thumbnail_min_area_pixels,
+                   gfx::Size thumbnail_max_size_pixels) {
   if (image.isNull())
     return SkBitmap();
 
   gfx::Size image_size = image.size();
 
   if (image_size.GetArea() < thumbnail_min_area_pixels)
     return image.getSkBitmap();
 
   if (image_size.width() <= thumbnail_max_size_pixels.width() &&
       image_size.height() <= thumbnail_max_size_pixels.height())
     return image.getSkBitmap();
 
   gfx::SizeF scaled_size = image_size;
 
   if (scaled_size.width() > thumbnail_max_size_pixels.width()) {
     scaled_size.Scale(thumbnail_max_size_pixels.width() / scaled_size.width());
   }
 
   if (scaled_size.height() > thumbnail_max_size_pixels.height()) {
     scaled_size.Scale(
         thumbnail_max_size_pixels.height() / scaled_size.height());
   }
 
   return skia::ImageOperations::Resize(image.getSkBitmap(),
                                        skia::ImageOperations::RESIZE_GOOD,
                                        static_cast<int>(scaled_size.width()),
                                        static_cast<int>(scaled_size.height()));
 }
+
+// The delimiter for a stack trace provided by WebKit.
+const char kStackFrameDelimiter[] = "\n    at ";
+
+// Get a stack trace from a WebKit console message.
+// There are three possible scenarios:
+// 1. WebKit gives us a stack trace in |stack_trace|.
+// 2. The stack trace is embedded in the error |message| by an internal
+//    script. This will be more useful than |stack_trace|, since |stack_trace|
+//    will include the internal bindings trace, instead of a developer's code.
+// 3. No stack trace is included. In this case, we should mock one up from
+//    the given line number and source.
+// |message| will be populated with the error message only (i.e., will not
+// include any stack trace).
+extensions::StackTrace GetStackTraceFromMessage(string16* message,
+                                                const string16& source,
+                                                const string16& stack_trace,
+                                                int32 line_number) {
+  extensions::StackTrace result;
+  std::vector<base::string16> pieces;
+  size_t index = 0;
+
+  if (message->find(base::UTF8ToUTF16(kStackFrameDelimiter)) !=
+          string16::npos) {
+    base::SplitStringUsingSubstr(*message,
+                                 base::UTF8ToUTF16(kStackFrameDelimiter),
+                                 &pieces);
+    *message = pieces[0];
+    index = 1;
+  } else if (!stack_trace.empty()) {
+    base::SplitStringUsingSubstr(stack_trace,
+                                 base::UTF8ToUTF16(kStackFrameDelimiter),
+                                 &pieces);
+  }
+
+  // If we got a stack trace, parse each frame from the text.
+  if (index < pieces.size()) {
+    for (; index < pieces.size(); ++index) {
+      scoped_ptr<extensions::StackFrame> frame =
+          extensions::StackFrame::CreateFromText(pieces[index]);
+      if (frame.get())
+        result.push_back(*frame);
+    }
+  }
+
+  if (result.empty()) {  // If we don't have a stack trace, mock one up.
+    result.push_back(
+        extensions::StackFrame(line_number,
+                               1u,  // column number
+                               source,
+                               EmptyString16() /* no function name */ ));
+  }
+
+  return result;
+}
+
 }  // namespace
 
 ChromeRenderViewObserver::ChromeRenderViewObserver(
     content::RenderView* render_view,
     ContentSettingsObserver* content_settings,
     ChromeRenderProcessObserver* chrome_render_process_observer,
     extensions::Dispatcher* extension_dispatcher)
     : content::RenderViewObserver(render_view),
       chrome_render_process_observer_(chrome_render_process_observer),
       extension_dispatcher_(extension_dispatcher),
@@ skipping 540 matching lines @@
     return;
 
   WebKit::WebTextInputType text_input_type =
       render_view()->GetWebView()->textInputInfo().type;
 
   render_view()->Send(new ChromeViewHostMsg_FocusedNodeTouched(
       routing_id(),
       text_input_type != WebKit::WebTextInputTypeNone));
 }
 
+void ChromeRenderViewObserver::DetailedConsoleMessageAdded(
+    const base::string16& message,
+    const base::string16& source,
+    const base::string16& stack_trace_string,
+    int32 line_number,
+    int32 severity_level) {
+  string16 trimmed_message = message;
+  extensions::StackTrace stack_trace = GetStackTraceFromMessage(
+      &trimmed_message,
+      source,
+      stack_trace_string,
+      line_number);
+  Send(new ChromeViewHostMsg_DetailedConsoleMessageAdded(routing_id(),
+                                                         trimmed_message,
+                                                         source,
+                                                         stack_trace,
+                                                         severity_level));
+}
+
 void ChromeRenderViewObserver::CapturePageInfoLater(int page_id,
                                                     bool preliminary_capture,
                                                     base::TimeDelta delay) {
   capture_timer_.Start(
       FROM_HERE,
       delay,
       base::Bind(&ChromeRenderViewObserver::CapturePageInfo,
                  base::Unretained(this),
                  page_id,
                  preliminary_capture));
@@ skipping 150 matching lines @@
     WebElement element = node.to<WebElement>();
     if (!element.hasTagName(tag_name))
       continue;
     WebString value = element.getAttribute(attribute_name);
     if (value.isNull() || !LowerCaseEqualsASCII(value, "refresh"))
       continue;
     return true;
   }
   return false;
 }