shell_browser_main.cc revision a3f6a49ab37290eeeb8db0f41ec0f1cb74a68be7 
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 "content/shell/browser/shell_browser_main.h"
6
7#include <iostream>
8
9#include "base/command_line.h"
10#include "base/file_util.h"
11#include "base/files/file_path.h"
12#include "base/files/scoped_temp_dir.h"
13#include "base/logging.h"
14#include "base/memory/scoped_ptr.h"
15#include "base/message_loop/message_loop.h"
16#include "base/strings/sys_string_conversions.h"
17#include "base/strings/utf_string_conversions.h"
18#include "base/threading/thread_restrictions.h"
19#include "content/public/browser/browser_main_runner.h"
20#include "content/shell/browser/shell.h"
21#include "content/shell/browser/webkit_test_controller.h"
22#include "content/shell/common/shell_switches.h"
23#include "content/shell/common/webkit_test_helpers.h"
24#include "content/test/webkit_support.h"
25#include "net/base/net_util.h"
26
27#if defined(OS_ANDROID)
28#include "base/run_loop.h"
29#include "content/shell/browser/shell_layout_tests_android.h"
30#endif
31
32namespace {
33
34GURL GetURLForLayoutTest(const std::string& test_name,
35                         base::FilePath* current_working_directory,
36                         bool* enable_pixel_dumping,
37                         std::string* expected_pixel_hash) {
38  // A test name is formated like file:///path/to/test'--pixel-test'pixelhash
39  std::string path_or_url = test_name;
40  std::string pixel_switch;
41  std::string pixel_hash;
42  std::string::size_type separator_position = path_or_url.find('\'');
43  if (separator_position != std::string::npos) {
44    pixel_switch = path_or_url.substr(separator_position + 1);
45    path_or_url.erase(separator_position);
46  }
47  separator_position = pixel_switch.find('\'');
48  if (separator_position != std::string::npos) {
49    pixel_hash = pixel_switch.substr(separator_position + 1);
50    pixel_switch.erase(separator_position);
51  }
52  if (enable_pixel_dumping) {
53    *enable_pixel_dumping =
54        (pixel_switch == "--pixel-test" || pixel_switch == "-p");
55  }
56  if (expected_pixel_hash)
57    *expected_pixel_hash = pixel_hash;
58
59  GURL test_url;
60#if defined(OS_ANDROID)
61  if (content::GetTestUrlForAndroid(path_or_url, &test_url))
62    return test_url;
63#endif
64
65  test_url = GURL(path_or_url);
66  if (!(test_url.is_valid() && test_url.has_scheme())) {
67    // We're outside of the message loop here, and this is a test.
68    base::ThreadRestrictions::ScopedAllowIO allow_io;
69#if defined(OS_WIN)
70    std::wstring wide_path_or_url =
71        base::SysNativeMBToWide(path_or_url);
72    base::FilePath local_file(wide_path_or_url);
73#else
74    base::FilePath local_file(path_or_url);
75#endif
76    if (!base::PathExists(local_file)) {
77      local_file = content::GetWebKitRootDirFilePath()
78          .Append(FILE_PATH_LITERAL("LayoutTests")).Append(local_file);
79    }
80    test_url = net::FilePathToFileURL(base::MakeAbsoluteFilePath(local_file));
81  }
82  base::FilePath local_path;
83  if (current_working_directory) {
84    // We're outside of the message loop here, and this is a test.
85    base::ThreadRestrictions::ScopedAllowIO allow_io;
86    if (net::FileURLToFilePath(test_url, &local_path))
87      *current_working_directory = local_path.DirName();
88    else
89      file_util::GetCurrentDirectory(current_working_directory);
90  }
91  return test_url;
92}
93
94bool GetNextTest(const CommandLine::StringVector& args,
95                 size_t* position,
96                 std::string* test) {
97  if (*position >= args.size())
98    return false;
99  if (args[*position] == FILE_PATH_LITERAL("-"))
100    return !!std::getline(std::cin, *test, '\n');
101#if defined(OS_WIN)
102  *test = WideToUTF8(args[(*position)++]);
103#else
104  *test = args[(*position)++];
105#endif
106  return true;
107}
108
109}  // namespace
110
111// Main routine for running as the Browser process.
112int ShellBrowserMain(
113    const content::MainFunctionParams& parameters,
114    const scoped_ptr<content::BrowserMainRunner>& main_runner) {
115  bool layout_test_mode =
116      CommandLine::ForCurrentProcess()->HasSwitch(switches::kDumpRenderTree);
117  base::ScopedTempDir browser_context_path_for_layout_tests;
118
119  if (layout_test_mode) {
120    CHECK(browser_context_path_for_layout_tests.CreateUniqueTempDir());
121    CHECK(!browser_context_path_for_layout_tests.path().MaybeAsASCII().empty());
122    CommandLine::ForCurrentProcess()->AppendSwitchASCII(
123        switches::kContentShellDataPath,
124        browser_context_path_for_layout_tests.path().MaybeAsASCII());
125
126#if defined(OS_ANDROID)
127    content::EnsureInitializeForAndroidLayoutTests();
128#endif
129  }
130
131  int exit_code = main_runner->Initialize(parameters);
132  DCHECK_LT(exit_code, 0)
133      << "BrowserMainRunner::Initialize failed in ShellBrowserMain";
134
135  if (exit_code >= 0)
136    return exit_code;
137
138  if (CommandLine::ForCurrentProcess()->HasSwitch(
139        switches::kCheckLayoutTestSysDeps)) {
140    base::MessageLoop::current()->PostTask(FROM_HERE,
141                                           base::MessageLoop::QuitClosure());
142    main_runner->Run();
143    content::Shell::CloseAllWindows();
144    main_runner->Shutdown();
145    return 0;
146  }
147
148  if (layout_test_mode) {
149    content::WebKitTestController test_controller;
150    {
151      // We're outside of the message loop here, and this is a test.
152      base::ThreadRestrictions::ScopedAllowIO allow_io;
153      base::FilePath temp_path;
154      base::GetTempDir(&temp_path);
155      test_controller.SetTempPath(temp_path);
156    }
157    std::string test_string;
158    CommandLine::StringVector args =
159        CommandLine::ForCurrentProcess()->GetArgs();
160    size_t command_line_position = 0;
161    bool ran_at_least_once = false;
162
163    std::cout << "#READY\n";
164    std::cout.flush();
165
166    while (GetNextTest(args, &command_line_position, &test_string)) {
167      if (test_string.empty())
168        continue;
169      if (test_string == "QUIT")
170        break;
171
172      bool enable_pixel_dumps;
173      std::string pixel_hash;
174      base::FilePath cwd;
175      GURL test_url = GetURLForLayoutTest(
176          test_string, &cwd, &enable_pixel_dumps, &pixel_hash);
177      if (!content::WebKitTestController::Get()->PrepareForLayoutTest(
178              test_url, cwd, enable_pixel_dumps, pixel_hash)) {
179        break;
180      }
181
182      ran_at_least_once = true;
183#if defined(OS_ANDROID)
184      // The message loop on Android is provided by the system, and does not
185      // offer a blocking Run() method. For layout tests, use a nested loop
186      // together with a base::RunLoop so it can block until a QuitClosure.
187      base::RunLoop run_loop;
188      run_loop.Run();
189#else
190      main_runner->Run();
191#endif
192
193      if (!content::WebKitTestController::Get()->ResetAfterLayoutTest())
194        break;
195
196#if defined(OS_ANDROID)
197      // There will be left-over tasks in the queue for Android because the
198      // main window is being destroyed. Run them before starting the next test.
199      base::MessageLoop::current()->RunUntilIdle();
200#endif
201    }
202    if (!ran_at_least_once) {
203      base::MessageLoop::current()->PostTask(FROM_HERE,
204                                             base::MessageLoop::QuitClosure());
205      main_runner->Run();
206    }
207
208#if defined(OS_ANDROID)
209    // Android should only execute Shutdown() here when running layout tests.
210    main_runner->Shutdown();
211#endif
212
213    exit_code = 0;
214  }
215
216#if !defined(OS_ANDROID)
217  if (!layout_test_mode)
218    exit_code = main_runner->Run();
219
220  main_runner->Shutdown();
221#endif
222
223  return exit_code;
224}
225