chrome/browser/extensions/error_console/error_console_browsertest.cc

   1 // Copyright 2013 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "chrome/browser/extensions/error_console/error_console.h"
   6
   7 #include "base/files/file_path.h"
   8 #include "base/prefs/pref_service.h"
   9 #include "base/strings/string16.h"
  10 #include "base/strings/stringprintf.h"
  11 #include "base/strings/utf_string_conversions.h"
  12 #include "chrome/browser/extensions/api/extension_action/extension_action_api.h"
  13 #include "chrome/browser/extensions/extension_browsertest.h"
  14 #include "chrome/browser/profiles/profile.h"
  15 #include "chrome/common/pref_names.h"
  16 #include "chrome/common/url_constants.h"
  17 #include "chrome/test/base/ui_test_utils.h"
  18 #include "extensions/browser/extension_error.h"
  19 #include "extensions/common/constants.h"
  20 #include "extensions/common/error_utils.h"
  21 #include "extensions/common/extension.h"
  22 #include "extensions/common/extension_urls.h"
  23 #include "extensions/common/feature_switch.h"
  24 #include "extensions/common/manifest_constants.h"
  25 #include "net/test/embedded_test_server/embedded_test_server.h"
  26 #include "testing/gtest/include/gtest/gtest.h"
  27 #include "url/gurl.h"
  28
  29 using base::string16;
  30 using base::UTF8ToUTF16;
  31
  32 namespace extensions {
  33
  34 namespace {
  35
  36 const char kTestingPage[] = "/extensions/test_file.html";
  37 const char kAnonymousFunction[] = "(anonymous function)";
  38 const char* kBackgroundPageName =
  39     extensions::kGeneratedBackgroundPageFilename;
  40 const int kNoFlags = 0;
  41
  42 const StackTrace& GetStackTraceFromError(const ExtensionError* error) {
  43   CHECK(error->type() == ExtensionError::RUNTIME_ERROR);
  44   return (static_cast<const RuntimeError*>(error))->stack_trace();
  45 }
  46
  47 // Verify that a given |frame| has the proper source and function name.
  48 void CheckStackFrame(const StackFrame& frame,
  49                      const std::string& source,
  50                      const std::string& function) {
  51   EXPECT_EQ(base::UTF8ToUTF16(source), frame.source);
  52   EXPECT_EQ(base::UTF8ToUTF16(function), frame.function);
  53 }
  54
  55 // Verify that all properties of a given |frame| are correct. Overloaded because
  56 // we commonly do not check line/column numbers, as they are too likely
  57 // to change.
  58 void CheckStackFrame(const StackFrame& frame,
  59                      const std::string& source,
  60                      const std::string& function,
  61                      size_t line_number,
  62                      size_t column_number) {
  63   CheckStackFrame(frame, source, function);
  64   EXPECT_EQ(line_number, frame.line_number);
  65   EXPECT_EQ(column_number, frame.column_number);
  66 }
  67
  68 // Verify that all properties of a given |error| are correct.
  69 void CheckError(const ExtensionError* error,
  70                 ExtensionError::Type type,
  71                 const std::string& id,
  72                 const std::string& source,
  73                 bool from_incognito,
  74                 const std::string& message) {
  75   ASSERT_TRUE(error);
  76   EXPECT_EQ(type, error->type());
  77   EXPECT_EQ(id, error->extension_id());
  78   EXPECT_EQ(base::UTF8ToUTF16(source), error->source());
  79   EXPECT_EQ(from_incognito, error->from_incognito());
  80   EXPECT_EQ(base::UTF8ToUTF16(message), error->message());
  81 }
  82
  83 // Verify that all properties of a JS runtime error are correct.
  84 void CheckRuntimeError(const ExtensionError* error,
  85                        const std::string& id,
  86                        const std::string& source,
  87                        bool from_incognito,
  88                        const std::string& message,
  89                        logging::LogSeverity level,
  90                        const GURL& context,
  91                        size_t expected_stack_size) {
  92   CheckError(error,
  93              ExtensionError::RUNTIME_ERROR,
  94              id,
  95              source,
  96              from_incognito,
  97              message);
  98
  99   const RuntimeError* runtime_error = static_cast<const RuntimeError*>(error);
 100   EXPECT_EQ(level, runtime_error->level());
 101   EXPECT_EQ(context, runtime_error->context_url());
 102   EXPECT_EQ(expected_stack_size, runtime_error->stack_trace().size());
 103 }
 104
 105 void CheckManifestError(const ExtensionError* error,
 106                         const std::string& id,
 107                         const std::string& message,
 108                         const std::string& manifest_key,
 109                         const std::string& manifest_specific) {
 110   CheckError(error,
 111              ExtensionError::MANIFEST_ERROR,
 112              id,
 113              // source is always the manifest for ManifestErrors.
 114              base::FilePath(kManifestFilename).AsUTF8Unsafe(),
 115              false,  // manifest errors are never from incognito.
 116              message);
 117
 118   const ManifestError* manifest_error =
 119       static_cast<const ManifestError*>(error);
 120   EXPECT_EQ(base::UTF8ToUTF16(manifest_key), manifest_error->manifest_key());
 121   EXPECT_EQ(base::UTF8ToUTF16(manifest_specific),
 122             manifest_error->manifest_specific());
 123 }
 124
 125 }  // namespace
 126
 127 class ErrorConsoleBrowserTest : public ExtensionBrowserTest {
 128  public:
 129   ErrorConsoleBrowserTest() : error_console_(NULL) { }
 130   virtual ~ErrorConsoleBrowserTest() { }
 131
 132  protected:
 133   // A helper class in order to wait for the proper number of errors to be
 134   // caught by the ErrorConsole. This will run the MessageLoop until a given
 135   // number of errors are observed.
 136   // Usage:
 137   //   ...
 138   //   ErrorObserver observer(3, error_console);
 139   //   <Cause three errors...>
 140   //   observer.WaitForErrors();
 141   //   <Perform any additional checks...>
 142   class ErrorObserver : public ErrorConsole::Observer {
 143    public:
 144     ErrorObserver(size_t errors_expected, ErrorConsole* error_console)
 145         : errors_observed_(0),
 146           errors_expected_(errors_expected),
 147           waiting_(false),
 148           error_console_(error_console) {
 149       error_console_->AddObserver(this);
 150     }
 151     virtual ~ErrorObserver() {
 152       if (error_console_)
 153         error_console_->RemoveObserver(this);
 154     }
 155
 156     // ErrorConsole::Observer implementation.
 157     void OnErrorAdded(const ExtensionError* error) override {
 158       ++errors_observed_;
 159       if (errors_observed_ >= errors_expected_) {
 160         if (waiting_)
 161           base::MessageLoopForUI::current()->Quit();
 162       }
 163     }
 164
 165     void OnErrorConsoleDestroyed() override { error_console_ = NULL; }
 166
 167     // Spin until the appropriate number of errors have been observed.
 168     void WaitForErrors() {
 169       if (errors_observed_ < errors_expected_) {
 170         waiting_ = true;
 171         content::RunMessageLoop();
 172         waiting_ = false;
 173       }
 174     }
 175
 176    private:
 177     size_t errors_observed_;
 178     size_t errors_expected_;
 179     bool waiting_;
 180
 181     ErrorConsole* error_console_;
 182
 183     DISALLOW_COPY_AND_ASSIGN(ErrorObserver);
 184   };
 185
 186   // The type of action which we take after we load an extension in order to
 187   // cause any errors.
 188   enum Action {
 189     // Navigate to a (non-chrome) page to allow a content script to run.
 190     ACTION_NAVIGATE,
 191     // Simulate a browser action click.
 192     ACTION_BROWSER_ACTION,
 193     // Navigate to the new tab page.
 194     ACTION_NEW_TAB,
 195     // Do nothing (errors will be caused by a background script,
 196     // or by a manifest/loading warning).
 197     ACTION_NONE
 198   };
 199
 200   void SetUpInProcessBrowserTestFixture() override {
 201     ExtensionBrowserTest::SetUpInProcessBrowserTestFixture();
 202
 203     // We need to enable the ErrorConsole FeatureSwitch in order to collect
 204     // errors. This should be enabled on any channel <= Dev, but let's make
 205     // sure (in case a test is running on, e.g., a beta channel).
 206     FeatureSwitch::error_console()->SetOverrideValue(
 207         FeatureSwitch::OVERRIDE_ENABLED);
 208   }
 209
 210   void SetUpOnMainThread() override {
 211     ExtensionBrowserTest::SetUpOnMainThread();
 212
 213     // Errors are only kept if we have Developer Mode enabled.
 214     profile()->GetPrefs()->SetBoolean(prefs::kExtensionsUIDeveloperMode, true);
 215
 216     error_console_ = ErrorConsole::Get(profile());
 217     CHECK(error_console_);
 218
 219     test_data_dir_ = test_data_dir_.AppendASCII("error_console");
 220   }
 221
 222   const GURL& GetTestURL() {
 223     if (test_url_.is_empty()) {
 224       CHECK(embedded_test_server()->InitializeAndWaitUntilReady());
 225       test_url_ = embedded_test_server()->GetURL(kTestingPage);
 226     }
 227     return test_url_;
 228   }
 229
 230   // Load the extension at |path|, take the specified |action|, and wait for
 231   // |expected_errors| errors. Populate |extension| with a pointer to the loaded
 232   // extension.
 233   void LoadExtensionAndCheckErrors(
 234       const std::string& path,
 235       int flags,
 236       size_t errors_expected,
 237       Action action,
 238       const Extension** extension) {
 239     ErrorObserver observer(errors_expected, error_console_);
 240     *extension =
 241         LoadExtensionWithFlags(test_data_dir_.AppendASCII(path), flags);
 242     ASSERT_TRUE(*extension);
 243
 244     switch (action) {
 245       case ACTION_NAVIGATE: {
 246         ui_test_utils::NavigateToURL(browser(), GetTestURL());
 247         break;
 248       }
 249       case ACTION_BROWSER_ACTION: {
 250         ExtensionActionAPI::Get(profile())->ExecuteExtensionAction(
 251             *extension, browser(), true);
 252         break;
 253       }
 254       case ACTION_NEW_TAB: {
 255         ui_test_utils::NavigateToURL(browser(),
 256                                      GURL(chrome::kChromeUINewTabURL));
 257         break;
 258       }
 259       case ACTION_NONE:
 260         break;
 261       default:
 262         NOTREACHED();
 263     }
 264
 265     observer.WaitForErrors();
 266
 267     // We should only have errors for a single extension, or should have no
 268     // entries, if no errors were expected.
 269     ASSERT_EQ(errors_expected > 0 ? 1u : 0u,
 270               error_console()->get_num_entries_for_test());
 271     ASSERT_EQ(
 272         errors_expected,
 273         error_console()->GetErrorsForExtension((*extension)->id()).size());
 274   }
 275
 276   ErrorConsole* error_console() { return error_console_; }
 277  private:
 278   // The URL used in testing for simple page navigations.
 279   GURL test_url_;
 280
 281   // Weak reference to the ErrorConsole.
 282   ErrorConsole* error_console_;
 283 };
 284
 285 // Test to ensure that we are successfully reporting manifest errors as an
 286 // extension is installed.
 287 IN_PROC_BROWSER_TEST_F(ErrorConsoleBrowserTest, ReportManifestErrors) {
 288   const Extension* extension = NULL;
 289   // We expect two errors - one for an invalid permission, and a second for
 290   // an unknown key.
 291   LoadExtensionAndCheckErrors("manifest_warnings",
 292                               ExtensionBrowserTest::kFlagIgnoreManifestWarnings,
 293                               2,
 294                               ACTION_NONE,
 295                               &extension);
 296
 297   const ErrorList& errors =
 298       error_console()->GetErrorsForExtension(extension->id());
 299
 300   // Unfortunately, there's not always a hard guarantee of order in parsing the
 301   // manifest, so there's not a definitive order in which these errors may
 302   // occur. As such, we need to determine which error corresponds to which
 303   // expected error.
 304   const ExtensionError* permissions_error = NULL;
 305   const ExtensionError* unknown_key_error = NULL;
 306   const char kFakeKey[] = "not_a_real_key";
 307   for (size_t i = 0; i < errors.size(); ++i) {
 308     ASSERT_EQ(ExtensionError::MANIFEST_ERROR, errors[i]->type());
 309     std::string utf8_key = base::UTF16ToUTF8(
 310         (static_cast<const ManifestError*>(errors[i]))->manifest_key());
 311     if (utf8_key == manifest_keys::kPermissions)
 312       permissions_error = errors[i];
 313     else if (utf8_key == kFakeKey)
 314       unknown_key_error = errors[i];
 315   }
 316   ASSERT_TRUE(permissions_error);
 317   ASSERT_TRUE(unknown_key_error);
 318
 319   const char kFakePermission[] = "not_a_real_permission";
 320   CheckManifestError(permissions_error,
 321                      extension->id(),
 322                      ErrorUtils::FormatErrorMessage(
 323                          manifest_errors::kPermissionUnknownOrMalformed,
 324                          kFakePermission),
 325                      manifest_keys::kPermissions,
 326                      kFakePermission);
 327
 328   CheckManifestError(unknown_key_error,
 329                      extension->id(),
 330                      ErrorUtils::FormatErrorMessage(
 331                          manifest_errors::kUnrecognizedManifestKey,
 332                          kFakeKey),
 333                      kFakeKey,
 334                      std::string());
 335 }
 336
 337 // Test that we do not store any errors unless the Developer Mode switch is
 338 // toggled on the profile.
 339 IN_PROC_BROWSER_TEST_F(ErrorConsoleBrowserTest,
 340                        DontStoreErrorsWithoutDeveloperMode) {
 341   profile()->GetPrefs()->SetBoolean(prefs::kExtensionsUIDeveloperMode, false);
 342
 343   const Extension* extension = NULL;
 344   // Same test as ReportManifestErrors, except we don't expect any errors since
 345   // we disable Developer Mode.
 346   LoadExtensionAndCheckErrors("manifest_warnings",
 347                               ExtensionBrowserTest::kFlagIgnoreManifestWarnings,
 348                               0,
 349                               ACTION_NONE,
 350                               &extension);
 351
 352   // Now if we enable developer mode, the errors should be reported...
 353   profile()->GetPrefs()->SetBoolean(prefs::kExtensionsUIDeveloperMode, true);
 354   EXPECT_EQ(2u, error_console()->GetErrorsForExtension(extension->id()).size());
 355
 356   // ... and if we disable it again, all errors which we were holding should be
 357   // removed.
 358   profile()->GetPrefs()->SetBoolean(prefs::kExtensionsUIDeveloperMode, false);
 359   EXPECT_EQ(0u, error_console()->GetErrorsForExtension(extension->id()).size());
 360 }
 361
 362 // Load an extension which, upon visiting any page, first sends out a console
 363 // log, and then crashes with a JS TypeError.
 364 IN_PROC_BROWSER_TEST_F(ErrorConsoleBrowserTest,
 365                        ContentScriptLogAndRuntimeError) {
 366   const Extension* extension = NULL;
 367   LoadExtensionAndCheckErrors(
 368       "content_script_log_and_runtime_error",
 369       kNoFlags,
 370       2u,  // Two errors: A log message and a JS type error.
 371       ACTION_NAVIGATE,
 372       &extension);
 373
 374   std::string script_url = extension->url().Resolve("content_script.js").spec();
 375
 376   const ErrorList& errors =
 377       error_console()->GetErrorsForExtension(extension->id());
 378
 379   // The first error should be a console log.
 380   CheckRuntimeError(errors[0],
 381                     extension->id(),
 382                     script_url,  // The source should be the content script url.
 383                     false,  // Not from incognito.
 384                     "Hello, World!",  // The error message is the log.
 385                     logging::LOG_INFO,
 386                     GetTestURL(),  // Content scripts run in the web page.
 387                     2u);
 388
 389   const StackTrace& stack_trace1 = GetStackTraceFromError(errors[0]);
 390   CheckStackFrame(stack_trace1[0],
 391                   script_url,
 392                   "logHelloWorld",  // function name
 393                   6u,  // line number
 394                   11u /* column number */ );
 395
 396   CheckStackFrame(stack_trace1[1],
 397                   script_url,
 398                   kAnonymousFunction,
 399                   9u,
 400                   1u);
 401
 402   // The second error should be a runtime error.
 403   CheckRuntimeError(errors[1],
 404                     extension->id(),
 405                     script_url,
 406                     false,  // not from incognito
 407                     "Uncaught TypeError: "
 408                         "Cannot set property 'foo' of undefined",
 409                     logging::LOG_ERROR,  // JS errors are always ERROR level.
 410                     GetTestURL(),
 411                     1u);
 412
 413   const StackTrace& stack_trace2 = GetStackTraceFromError(errors[1]);
 414   CheckStackFrame(stack_trace2[0],
 415                   script_url,
 416                   kAnonymousFunction,
 417                   12u,
 418                   1u);
 419 }
 420
 421 // Catch an error from a BrowserAction; this is more complex than a content
 422 // script error, since browser actions are routed through our own code.
 423 IN_PROC_BROWSER_TEST_F(ErrorConsoleBrowserTest, BrowserActionRuntimeError) {
 424   const Extension* extension = NULL;
 425   LoadExtensionAndCheckErrors(
 426       "browser_action_runtime_error",
 427       kNoFlags,
 428       1u,  // One error: A reference error from within the browser action.
 429       ACTION_BROWSER_ACTION,
 430       &extension);
 431
 432   std::string script_url = extension->url().Resolve("browser_action.js").spec();
 433
 434   const ErrorList& errors =
 435       error_console()->GetErrorsForExtension(extension->id());
 436
 437   std::string event_bindings_str =
 438       base::StringPrintf("extensions::%s", kEventBindings);
 439
 440   std::string event_dispatch_to_listener_str =
 441       base::StringPrintf("Event.publicClass.%s [as dispatchToListener]",
 442                          kAnonymousFunction);
 443
 444   CheckRuntimeError(
 445       errors[0],
 446       extension->id(),
 447       script_url,
 448       false,  // not incognito
 449       "Error in event handler for browserAction.onClicked: ReferenceError: "
 450           "baz is not defined",
 451       logging::LOG_ERROR,
 452       extension->url().Resolve(kBackgroundPageName),
 453       1u);
 454
 455   const StackTrace& stack_trace = GetStackTraceFromError(errors[0]);
 456   // Note: This test used to have a stack trace of length 6 that contains stack
 457   // frames in the extension code, but since crbug.com/404406 was fixed only
 458   // stack frames within user-defined extension code are printed.
 459
 460   CheckStackFrame(stack_trace[0], script_url, kAnonymousFunction);
 461 }
 462
 463 // Test that we can catch an error for calling an API with improper arguments.
 464 IN_PROC_BROWSER_TEST_F(ErrorConsoleBrowserTest, BadAPIArgumentsRuntimeError) {
 465   const Extension* extension = NULL;
 466   LoadExtensionAndCheckErrors(
 467       "bad_api_arguments_runtime_error",
 468       kNoFlags,
 469       1,  // One error: call an API with improper arguments.
 470       ACTION_NONE,
 471       &extension);
 472
 473   const ErrorList& errors =
 474       error_console()->GetErrorsForExtension(extension->id());
 475
 476   std::string schema_utils_str =
 477       base::StringPrintf("extensions::%s", kSchemaUtils);
 478
 479   CheckRuntimeError(
 480       errors[0],
 481       extension->id(),
 482       schema_utils_str,  // API calls are checked in schemaUtils.js.
 483       false,  // not incognito
 484       "Uncaught Error: Invocation of form "
 485           "tabs.get(string, function) doesn't match definition "
 486           "tabs.get(integer tabId, function callback)",
 487       logging::LOG_ERROR,
 488       extension->url().Resolve(kBackgroundPageName),
 489       1u);
 490
 491   const StackTrace& stack_trace = GetStackTraceFromError(errors[0]);
 492   ASSERT_EQ(1u, stack_trace.size());
 493   CheckStackFrame(stack_trace[0],
 494                   schema_utils_str,
 495                   kAnonymousFunction);
 496 }
 497
 498 // Test that we catch an error when we try to call an API method without
 499 // permission.
 500 IN_PROC_BROWSER_TEST_F(ErrorConsoleBrowserTest, BadAPIPermissionsRuntimeError) {
 501   const Extension* extension = NULL;
 502   LoadExtensionAndCheckErrors(
 503       "bad_api_permissions_runtime_error",
 504       kNoFlags,
 505       1,  // One error: we try to call addUrl() on chrome.history without
 506           // permission, which results in a TypeError.
 507       ACTION_NONE,
 508       &extension);
 509
 510   std::string script_url = extension->url().Resolve("background.js").spec();
 511
 512   const ErrorList& errors =
 513       error_console()->GetErrorsForExtension(extension->id());
 514
 515   CheckRuntimeError(
 516       errors[0],
 517       extension->id(),
 518       script_url,
 519       false,  // not incognito
 520       "Uncaught TypeError: Cannot read property 'addUrl' of undefined",
 521       logging::LOG_ERROR,
 522       extension->url().Resolve(kBackgroundPageName),
 523       1u);
 524
 525   const StackTrace& stack_trace = GetStackTraceFromError(errors[0]);
 526   ASSERT_EQ(1u, stack_trace.size());
 527   CheckStackFrame(stack_trace[0],
 528                   script_url,
 529                   kAnonymousFunction,
 530                   5u, 1u);
 531 }
 532
 533 // Test that if there is an error in an HTML page loaded by an extension (most
 534 // common with apps), it is caught and reported by the ErrorConsole.
 535 IN_PROC_BROWSER_TEST_F(ErrorConsoleBrowserTest, BadExtensionPage) {
 536   const Extension* extension = NULL;
 537   LoadExtensionAndCheckErrors(
 538       "bad_extension_page",
 539       kNoFlags,
 540       1,  // One error: the page will load JS which has a reference error.
 541       ACTION_NEW_TAB,
 542       &extension);
 543 }
 544
 545 // Test that extension errors that go to chrome.runtime.lastError are caught
 546 // and reported by the ErrorConsole.
 547 IN_PROC_BROWSER_TEST_F(ErrorConsoleBrowserTest, CatchesLastError) {
 548   const Extension* extension = NULL;
 549   LoadExtensionAndCheckErrors(
 550       "trigger_last_error",
 551       kNoFlags,
 552       1,  // One error, which is sent through last error when trying to remove
 553           // a non-existent permisison.
 554       ACTION_NONE,
 555       &extension);
 556
 557   const ErrorList& errors =
 558       error_console()->GetErrorsForExtension(extension->id());
 559   ASSERT_EQ(1u, errors.size());
 560
 561   std::string script_url = extension->url().Resolve("background.js").spec();
 562
 563   CheckRuntimeError(
 564       errors[0],
 565       extension->id(),
 566       script_url,
 567       false,  // not incognito
 568       "Unchecked runtime.lastError while running permissions.remove: "
 569           "'foobar' is not a recognized permission.",
 570       logging::LOG_ERROR,
 571       extension->url().Resolve(kBackgroundPageName),
 572       1u);
 573
 574   const StackTrace& stack_trace = GetStackTraceFromError(errors[0]);
 575   ASSERT_EQ(1u, stack_trace.size());
 576   CheckStackFrame(stack_trace[0],
 577                   script_url,
 578                   kAnonymousFunction,
 579                   12u, 20u);
 580 }
 581
 582 }  // namespace extensions