import org.openqa.selenium.remote.service.DriverService; //导入依赖的package包/类
private ProxyDriverIntegrator getProxyDriverIntegrator(RequestFilter recordRequestFilter,
                                                       WebDriverSupplier webDriverSupplier,
                                                       DriverServiceSupplier driverServiceSupplier,
                                                       @Named(PATH_TO_DRIVER) String pathToDriverExecutable,
                                                       @Named(SCREEN) String screen,
                                                       @Named(TIMEOUT) int timeout,
                                                       ResponseFilter responseFilter) throws IOException {
    BrowserMobProxy proxy = createBrowserMobProxy(timeout, recordRequestFilter, responseFilter);
    proxy.start(0);
    logger.info("Proxy running on port " + proxy.getPort());
    Proxy seleniumProxy = createSeleniumProxy(proxy);
    DesiredCapabilities desiredCapabilities = createDesiredCapabilities(seleniumProxy);
    DriverService driverService = driverServiceSupplier.getDriverService(pathToDriverExecutable, screen);
    WebDriver driver = webDriverSupplier.get(driverService, desiredCapabilities);

    return new ProxyDriverIntegrator(driver, proxy, driverService);
}
 

import org.openqa.selenium.remote.service.DriverService; //导入依赖的package包/类
public WebDriver start(DriverServiceFactory factory, DriverService driverService) {
    WebDriver driver = null;
    for (int i = 0; i < retries && driver == null; i++) {
        log.info("trying to start {}/{} (attempt/max attempts)", i, retries);
        driver = startServiceAndCreateWebdriver(driverService, factory);
        log.info("is started: {}", driver == null);
        if (driver == null) {
            try {
                timeUnit.sleep(2);
            } catch (InterruptedException e) {
                log.error(e.getMessage(), e);
            }
        }
    }
    return driver;
}
 

import org.openqa.selenium.remote.service.DriverService; //导入依赖的package包/类
public final DriverService getDriverService() {
    try {
        if (driverService == null) {
            driverService = createDriverService();
            wasRunning = driverService.isRunning();
            if (wasRunning) {
                LOGGER.info("Driver service {} is already running", driverService.getUrl());
            } else {
                driverService.start();
                LOGGER.info("Driver service {} started", driverService.getUrl());
            }
        }
        return driverService;
    } catch (IOException e) {
        throw Throwables.propagate(e);
    }
}
 

import org.openqa.selenium.remote.service.DriverService; //导入依赖的package包/类
public WebDriverEx createWebDriver(DriverService driverService,
                                      DesiredCapabilities desiredCapabilities,
                                      SiteConfig siteConfig,
                                      DriverConfig driverConfig) throws IOException {
    driverService.start();

    //自定义HttpClientFactory用于设置命令超时时间
    ApacheHttpClient.Factory httpClientFactory = createHttpClientFactory(siteConfig, driverConfig);
    HttpCommandExecutor httpCommandExecutor = new HttpCommandExecutor(
            ImmutableMap.<String, CommandInfo>of(), driverService.getUrl(), httpClientFactory);
    WebDriverEx webDriver = new WebDriverEx(httpCommandExecutor, desiredCapabilities);
    webDriver.setDriverService(driverService);
    webDriver.setCreatedTime(new Date());

    webDriver.manage().timeouts().implicitlyWait(driverConfig.getImplicitlyWait(), TimeUnit.MILLISECONDS);
    webDriver.manage().timeouts().pageLoadTimeout(driverConfig.getPageLoadTimeout(), TimeUnit.MILLISECONDS);
    webDriver.manage().timeouts().setScriptTimeout(driverConfig.getScriptTimeout(), TimeUnit.MILLISECONDS);

    return webDriver;
}
 

import org.openqa.selenium.remote.service.DriverService; //导入依赖的package包/类
@Override
public DriverService getDriverService(String pathToDriverExecutable, String screenToUse) throws IOException {
    return getBuilder()
            .usingDriverExecutable(new File(pathToDriverExecutable))
            .usingAnyFreePort()
            .withEnvironment(ImmutableMap.of("DISPLAY", screenToUse))
            .build();
}
 

import org.openqa.selenium.remote.service.DriverService; //导入依赖的package包/类
@Test
public void invokesTheCorrectMethodsOfTheBuilder() throws IOException {
    DriverService.Builder builder = mock(DriverService.Builder.class, RETURNS_DEEP_STUBS);

    DriverServiceSupplierBase driverServiceSupplierBase = new DriverServiceSupplierBase() {
        @Override
        protected DriverService.Builder getBuilder() {
            return builder;
        }
    };

    DriverService driverService = driverServiceSupplierBase.getDriverService(driverExecutableFileName, screenToUse);

    verify(builder).usingDriverExecutable(eq(driverExecutableFile));
}
 

import org.openqa.selenium.remote.service.DriverService; //导入依赖的package包/类
@Test
public void providesAccessToConnectedDriverProxyAndDriverService() {
    WebDriver driver = mock(WebDriver.class);
    BrowserMobProxy proxy = mock(BrowserMobProxy.class);
    DriverService driverService = mock(DriverService.class);

    ProxyDriverIntegrator proxyDriverIntegrator = new ProxyDriverIntegrator(driver, proxy, driverService);

    assertEquals(driver, proxyDriverIntegrator.getWebDriver());
    assertEquals(proxy, proxyDriverIntegrator.getProxy());
    assertEquals(driverService, proxyDriverIntegrator.getDriverService());
}
 

import org.openqa.selenium.remote.service.DriverService; //导入依赖的package包/类
private WebDriver startServiceAndCreateWebdriver(DriverService driverService, DriverServiceFactory factory) {
    ExecutorService service = Executors.newFixedThreadPool(1);

    @SuppressWarnings("unchecked")
    Callable<WebDriver> startJob = () -> {
        if (!driverService.isRunning()) {
            log.info("starting");
            driverService.start();
        }
        log.info("try to create webdriver");
        return factory.createWebDriver(driverService);
    };

    Future<WebDriver> startFuture = service.submit(startJob);
    try {
        log.info("waiting for webdriver");
        return startFuture.get(timeout, timeUnit);
    } catch (ExecutionException | InterruptedException | TimeoutException e) {
        log.warn(e.getMessage(), e);
        if (driverService.isRunning()) {
            driverService.stop();
        }
    } finally {
        service.shutdownNow();
    }
    return null;
}
 

import org.openqa.selenium.remote.service.DriverService; //导入依赖的package包/类
/**
 * Gets a web driver for a given browser
 * @param browser The browser to get a driver for
 * @return
 * @throws IOException
 */
public static synchronized RemoteWebDriver getDriver(Browser browser) throws IOException {
    if (global == null) {
        DriverService service = start(browser);
        global = new RemoteWebDriver(service.getUrl(), getDesiredBrowserCapabilities(browser));
        drivers.put(global, service);
    }
    return global;
}
 

import org.openqa.selenium.remote.service.DriverService; //导入依赖的package包/类
/**
 * Starts a selenium service for a given browser
 * @param browser The browser to start the service for
 * @return
 * @throws IOException
 */
public static DriverService start(Browser browser) throws IOException {
    BrowserDriverProvider provider = getProvider(browser);
    DriverService service = new ChromeDriverService.Builder().usingDriverExecutable(provider.getDriverFile()).usingAnyFreePort().build();
    service.start();
    return service;
}
 

import org.openqa.selenium.remote.service.DriverService; //导入依赖的package包/类
@Override
protected DriverService createDriverService() {
    Builder builder = new ChromeDriverService.Builder();
    if (port != null) builder.usingPort(port);
    if (driverExecutable != null) builder.usingDriverExecutable(driverExecutable);
    if (environment != null) builder.withEnvironment(environment);
    if (logFile != null) builder.withLogFile(logFile);
    if (verbose != null) builder.withVerbose(verbose);
    if (silent != null) builder.withSilent(silent);
    return builder.build();
}
 

import org.openqa.selenium.remote.service.DriverService; //导入依赖的package包/类
@Override
protected DriverService createDriverService() {
    Builder builder = new GeckoDriverService.Builder();
    if (port != null) builder.usingPort(port);
    if (driverExecutable != null) builder.usingDriverExecutable(driverExecutable);
    if (environment != null) builder.withEnvironment(environment);
    if (logFile != null) builder.withLogFile(logFile);
    return builder.build();
}
 

import org.openqa.selenium.remote.service.DriverService; //导入依赖的package包/类
@Override
public DriverService createDriverService() {
    Builder builder = new PhantomJSDriverService.Builder();

    if (driverExecutable != null) builder.usingPhantomJSExecutable(driverExecutable);
    if (ghostDriver != null) builder.usingGhostDriver(ghostDriver);
    if (port != null) builder.usingPort(port);
    if (environment != null) builder.withEnvironment(environment);
    if (logFile != null) builder.withLogFile(logFile);
    if (proxy != null) builder.withProxy(new Proxy(proxy));
    if (commandLineArguments != null) builder.usingCommandLineArguments(commandLineArguments);
    if (ghostDriverCommandLineArguments != null) builder.usingGhostDriverCommandLineArguments(ghostDriverCommandLineArguments);

    return builder.build();
}
 

import org.openqa.selenium.remote.service.DriverService; //导入依赖的package包/类
@Override
public DriverService createDriverService() {
    Builder builder = new InternetExplorerDriverService.Builder();
    if (port != null) builder.usingPort(port);
    if (driverExecutable != null) builder.usingDriverExecutable(driverExecutable);
    if (environment != null) builder.withEnvironment(environment);
    if (logFile != null) builder.withLogFile(logFile);
    if (logLevel != null) builder.withLogLevel(InternetExplorerDriverLogLevel.valueOf(logLevel.toUpperCase()));
    if (engineImplementation != null) builder.withEngineImplementation(InternetExplorerDriverEngine.valueOf(engineImplementation.toUpperCase()));
    if (host != null) builder.withHost(host);
    if (extractPath != null) builder.withExtractPath(extractPath);
    if (silent != null) builder.withSilent(silent);
    return builder.build();
}
 

import org.openqa.selenium.remote.service.DriverService; //导入依赖的package包/类
@Override
public WebDriver create(WebDriverFactory webDriverFactory, DesiredCapabilities desiredCapabilities) {
    ChromeDriverServiceProperties serviceProperties = webDriverFactory.driverServices == null ? null : webDriverFactory.driverServices.getChrome();
    DriverService driverService = serviceProperties == null ? null : serviceProperties.getDriverService();
    return driverService == null ?
            new ChromeDriver(new ChromeOptions().merge(desiredCapabilities))
            : new RemoteWebDriver(driverService.getUrl(), desiredCapabilities);
}
 

import org.openqa.selenium.remote.service.DriverService; //导入依赖的package包/类
public DriverService getDriverService() {
    return driverService;
}
 

import org.openqa.selenium.remote.service.DriverService; //导入依赖的package包/类
public void setDriverService(DriverService driverService) {
    this.driverService = driverService;
}
 

import org.openqa.selenium.remote.service.DriverService; //导入依赖的package包/类
@Override
protected DriverService.Builder getBuilder() {
    return new ChromeDriverService.Builder();
}
 

import org.openqa.selenium.remote.service.DriverService; //导入依赖的package包/类
public AppiumCommandExecutor(Map<String, CommandInfo> additionalCommands, DriverService service,
    HttpClient.Factory httpClientFactory) {
    super(additionalCommands, service.getUrl(), httpClientFactory);
    this.service = service;
}
 

import org.openqa.selenium.remote.service.DriverService; //导入依赖的package包/类
public MyChromeDriverCommandExecutor(DriverService service) {
	super(service, CHROME_COMMAND_NAME_TO_URL);
}