diff --git a/tools/chrome_remote_control/chrome_remote_control/__init__.py b/tools/chrome_remote_control/chrome_remote_control/__init__.py
index 8702e417fb72f9..d08a896fe26c18 100644
--- a/tools/chrome_remote_control/chrome_remote_control/__init__.py
+++ b/tools/chrome_remote_control/chrome_remote_control/__init__.py
@@ -4,10 +4,11 @@
 """A library for chrome-based tests.
 
 """
+from chrome_remote_control.browser import Browser
 from chrome_remote_control.browser_finder import FindBrowser
 from chrome_remote_control.browser_finder import GetAllAvailableBrowserTypes
+from chrome_remote_control.browser_gone_exception import BrowserGoneException
 from chrome_remote_control.browser_options import BrowserOptions
-from chrome_remote_control.browser import Browser
 from chrome_remote_control.tab import Tab
 from chrome_remote_control.tab_crash_exception import TabCrashException
 from chrome_remote_control.util import TimeoutException, WaitFor
diff --git a/tools/chrome_remote_control/chrome_remote_control/android_browser_backend.py b/tools/chrome_remote_control/chrome_remote_control/android_browser_backend.py
index 19e03af141cc00..961501cc077fbb 100644
--- a/tools/chrome_remote_control/chrome_remote_control/android_browser_backend.py
+++ b/tools/chrome_remote_control/chrome_remote_control/android_browser_backend.py
@@ -7,13 +7,14 @@
 
 from chrome_remote_control import adb_commands
 from chrome_remote_control import browser_backend
+from chrome_remote_control import browser_gone_exception
 
 class AndroidBrowserBackend(browser_backend.BrowserBackend):
   """The backend for controlling a browser instance running on Android.
   """
-  def __init__(self, options, extra_browser_args, adb, package,
+  def __init__(self, options, adb, package,
                is_content_shell, cmdline_file, activity, devtools_remote_port):
-    super(AndroidBrowserBackend, self).__init__(is_content_shell)
+    super(AndroidBrowserBackend, self).__init__(is_content_shell, options)
     # Initialize fields so that an explosion during init doesn't break in Close.
     self._options = options
     self._adb = adb
@@ -23,13 +24,6 @@ def __init__(self, options, extra_browser_args, adb, package,
     self._port = 9222
     self._devtools_remote_port = devtools_remote_port
 
-    # Beginnings of a basic command line.
-    if is_content_shell:
-      pseudo_exec_name = 'content_shell'
-    else:
-      pseudo_exec_name = 'chrome'
-    args = [pseudo_exec_name, '--disable-fre']
-
     # Kill old browser.
     self._adb.KillAll(self._package)
     self._adb.KillAll('forwarder')
@@ -46,10 +40,14 @@ def __init__(self, options, extra_browser_args, adb, package,
       pass
 
     # Set up the command line.
-    if extra_browser_args:
-      args.extend(extra_browser_args)
-    args.extend(options.extra_browser_args)
-    args.extend(self._common_chrome_browser_args)
+    if is_content_shell:
+      pseudo_exec_name = 'content_shell'
+    else:
+      pseudo_exec_name = 'chrome'
+
+    args = [pseudo_exec_name]
+    args.extend(self.GetBrowserStartupArgs())
+
     with tempfile.NamedTemporaryFile() as f:
       def EscapeIfNeeded(arg):
         return arg.replace(' ', '" "')
@@ -67,7 +65,8 @@ def EscapeIfNeeded(arg):
         logging.critical(
             'android_browser_backend: Could not find preferences file ' +
             '%s for %s' % (prefs_file, self._package))
-        raise browser_backend.BrowserGoneException('Missing preferences file.')
+        raise browser_gone_exception.BrowserGoneException(
+          'Missing preferences file.')
 
       with tempfile.NamedTemporaryFile() as raw_f:
         self._adb.Pull(prefs_file, raw_f.name)
@@ -106,6 +105,11 @@ def EscapeIfNeeded(arg):
       self.Close()
       raise
 
+  def GetBrowserStartupArgs(self):
+    args = super(AndroidBrowserBackend, self).GetBrowserStartupArgs()
+    args.append('--disable-fre')
+    return args
+
   def __del__(self):
     self.Close()
 
diff --git a/tools/chrome_remote_control/chrome_remote_control/android_browser_finder.py b/tools/chrome_remote_control/chrome_remote_control/android_browser_finder.py
index ca563cee76f506..92c6a280a1cd1d 100644
--- a/tools/chrome_remote_control/chrome_remote_control/android_browser_finder.py
+++ b/tools/chrome_remote_control/chrome_remote_control/android_browser_finder.py
@@ -4,7 +4,7 @@
 """Finds android browsers that can be controlled by chrome_remote_control."""
 
 import os
-import logging
+import logging as real_logging
 import re
 import subprocess
 
@@ -49,12 +49,12 @@ def __init__(self, browser_type, options, *args):
   def __repr__(self):
     return 'PossibleAndroidBrowser(browser_type=%s)' % self.browser_type
 
-  def Create(self, extra_browser_args=None):
+  def Create(self):
     backend = android_browser_backend.AndroidBrowserBackend(
-        self._options, extra_browser_args, *self._args)
+        self._options, *self._args)
     return browser.Browser(backend)
 
-def FindAllAvailableBrowsers(options):
+def FindAllAvailableBrowsers(options, logging=real_logging):
   """Finds all the desktop browsers available on this machine."""
   if not adb_commands.IsAndroidSupported():
     return []
@@ -68,14 +68,14 @@ def FindAllAvailableBrowsers(options):
                               stdin=devnull)
       stdout, _ = proc.communicate()
       if re.search(re.escape('????????????\tno permissions'), stdout) != None:
-        logging.warning(
+        logging.warn(
             ('adb devices reported a permissions error. Consider '
             'restarting adb as root:'))
-        logging.warning('  adb kill-server')
-        logging.warning('  sudo `which adb` devices\n\n')
+        logging.warn('  adb kill-server')
+        logging.warn('  sudo `which adb` devices\n\n')
   except OSError:
     logging.info('No adb command found. ' +
-                 'Will not try searching for Android browsers.')
+             'Will not try searching for Android browsers.')
     return []
 
   device = None
diff --git a/tools/chrome_remote_control/chrome_remote_control/android_browser_finder_unittest.py b/tools/chrome_remote_control/chrome_remote_control/android_browser_finder_unittest.py
index c2de1640b3e9c3..1bdba4a713a9b7 100644
--- a/tools/chrome_remote_control/chrome_remote_control/android_browser_finder_unittest.py
+++ b/tools/chrome_remote_control/chrome_remote_control/android_browser_finder_unittest.py
@@ -1,13 +1,22 @@
 # 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.
-import logging
 import unittest
 
 from chrome_remote_control import android_browser_finder
 from chrome_remote_control import browser_options
 from chrome_remote_control import system_stub
 
+class LoggingStub(object):
+  def __init__(self):
+    self.warnings = []
+
+  def info(self, msg, *args):
+    pass
+
+  def warn(self, msg, *args):
+    self.warnings.append(msg % args)
+
 class AndroidBrowserFinderTest(unittest.TestCase):
   def setUp(self):
     self._stubs = system_stub.Override(android_browser_finder,
@@ -42,21 +51,10 @@ def test_adb_permissions_error(self):
 * daemon started successfully *
 """)
 
-    warnings = []
-    class TempFilter(logging.Filter):
-      def filter(self, record):
-        warnings.append(record)
-        return 0
-    temp_filter = TempFilter()
-
-    try:
-      logger = logging.getLogger()
-      logger.addFilter(temp_filter)
-
-      browsers = android_browser_finder.FindAllAvailableBrowsers(options)
-    finally:
-      logger.removeFilter(temp_filter)
-    self.assertEquals(3, len(warnings))
+    log_stub = LoggingStub()
+    browsers = android_browser_finder.FindAllAvailableBrowsers(
+      options, log_stub)
+    self.assertEquals(3, len(log_stub.warnings))
     self.assertEquals(0, len(browsers))
 
 
@@ -66,21 +64,10 @@ def test_adb_two_devices(self):
     self._stubs.adb_commands.attached_devices = ['015d14fec128220c',
                                                  '015d14fec128220d']
 
-    warnings = []
-    class TempFilter(logging.Filter):
-      def filter(self, record):
-        warnings.append(record)
-        return 0
-    temp_filter = TempFilter()
-
-    try:
-      logger = logging.getLogger()
-      logger.addFilter(temp_filter)
-
-      browsers = android_browser_finder.FindAllAvailableBrowsers(options)
-    finally:
-      logger.removeFilter(temp_filter)
-    self.assertEquals(1, len(warnings))
+    log_stub = LoggingStub()
+    browsers = android_browser_finder.FindAllAvailableBrowsers(
+      options, log_stub)
+    self.assertEquals(1, len(log_stub.warnings))
     self.assertEquals(0, len(browsers))
 
   def test_adb_one_device(self):
diff --git a/tools/chrome_remote_control/chrome_remote_control/browser.py b/tools/chrome_remote_control/chrome_remote_control/browser.py
index a100bd9a75b70c..82db1222f7fa11 100644
--- a/tools/chrome_remote_control/chrome_remote_control/browser.py
+++ b/tools/chrome_remote_control/chrome_remote_control/browser.py
@@ -3,9 +3,10 @@
 # found in the LICENSE file.
 import os
 
-from chrome_remote_control import replay_server
 from chrome_remote_control import temporary_http_server
 from chrome_remote_control import browser_credentials
+from chrome_remote_control import wpr_modes
+from chrome_remote_control import wpr_server
 
 class Browser(object):
   """A running browser instance that can be controlled in a limited way.
@@ -20,6 +21,8 @@ class Browser(object):
   """
   def __init__(self, backend):
     self._backend = backend
+    self._http_server = None
+    self._wpr_server = None
     self.credentials = browser_credentials.BrowserCredentials()
 
   def __enter__(self):
@@ -44,18 +47,53 @@ def ConnectToNthTab(self, index):
     return self._backend.ConnectToNthTab(self, index)
 
   def Close(self):
+    if self._wpr_server:
+      self._wpr_server.Close()
+      self._wpr_server = None
+
+    if self._http_server:
+      self._http_server.Close()
+      self._http_server = None
+
     self._backend.Close()
     self.credentials = None
 
-  def CreateTemporaryHTTPServer(self, path):
-    return temporary_http_server.TemporaryHTTPServer(self._backend, path)
+  @property
+  def http_server(self):
+    return self._http_server
+
+  def SetHTTPServerDirectory(self, path):
+    if path:
+      abs_path = os.path.abspath(path)
+      if self._http_server and self._http_server.path == path:
+        return
+    else:
+      abs_path = None
+
+    if self._http_server:
+      self._http_server.Close()
+      self._http_server = None
+
+    if not abs_path:
+      return
+
+    self._http_server = temporary_http_server.TemporaryHTTPServer(
+      self._backend, abs_path)
+
+  def SetReplayArchivePath(self, archive_path):
+    if self._wpr_server:
+      self._wpr_server.Close()
+      self._wpr_server = None
+
+    if not archive_path:
+      return None
+
+    if self._backend.wpr_mode == wpr_modes.WPR_OFF:
+      return
 
-  @classmethod
-  def CanUseReplayServer(cls, archive_path, use_record_mode):
-    return os.path.isfile(archive_path) or use_record_mode
+    use_record_mode = self._backend.wpr_mode == wpr_modes.WPR_RECORD
+    if not use_record_mode:
+      assert os.path.isfile(archive_path)
 
-  def CreateReplayServer(self, archive_path, use_record_mode):
-    replay_class = replay_server.DoNothingReplayServer
-    if self.CanUseReplayServer(archive_path, use_record_mode):
-      replay_class = replay_server.ReplayServer
-    return replay_class(self._backend, archive_path, use_record_mode)
+    self._wpr_server = wpr_server.ReplayServer(
+      self._backend, archive_path, use_record_mode)
diff --git a/tools/chrome_remote_control/chrome_remote_control/browser_backend.py b/tools/chrome_remote_control/chrome_remote_control/browser_backend.py
index b72771477a995d..ad8a63215a7670 100644
--- a/tools/chrome_remote_control/chrome_remote_control/browser_backend.py
+++ b/tools/chrome_remote_control/chrome_remote_control/browser_backend.py
@@ -6,47 +6,56 @@
 import socket
 import json
 
+from chrome_remote_control import browser_gone_exception
 from chrome_remote_control import inspector_backend
 from chrome_remote_control import tab
 from chrome_remote_control import util
-
-class BrowserGoneException(Exception):
-  pass
+from chrome_remote_control import wpr_modes
+from chrome_remote_control import wpr_server
 
 class BrowserBackend(object):
   """A base class for broser backends. Provides basic functionality
   once a remote-debugger port has been established."""
-  _common_chrome_browser_args = [
-    '--disable-background-networking',
-    '--no-first-run',
-  ]
-
-  def __init__(self, is_content_shell):
+  def __init__(self, is_content_shell, options):
     self.is_content_shell = is_content_shell
+    self.options = options
     self._port = None
 
+  def GetBrowserStartupArgs(self):
+    args = []
+    args.extend(self.options.extra_browser_args)
+    args.append('--disable-background-networking')
+    args.append('--no-first-run')
+    if self.options.wpr_mode != wpr_modes.WPR_OFF:
+      args.extend(wpr_server.CHROME_FLAGS)
+    return args
+
+  @property
+  def wpr_mode(self):
+    return self.options.wpr_mode
+
   def _WaitForBrowserToComeUp(self):
     def IsBrowserUp():
       try:
         self._ListTabs()
       except socket.error:
         if not self.IsBrowserRunning():
-          raise BrowserGoneException()
+          raise browser_gone_exception.BrowserGoneException()
         return False
       except httplib.BadStatusLine:
         if not self.IsBrowserRunning():
-          raise BrowserGoneException()
+          raise browser_gone_exception.BrowserGoneException()
         return False
       except urllib2.URLError:
         if not self.IsBrowserRunning():
-          raise BrowserGoneException()
+          raise browser_gone_exception.BrowserGoneException()
         return False
       else:
         return True
     try:
       util.WaitFor(IsBrowserUp, timeout=30)
     except util.TimeoutException:
-      raise BrowserGoneException()
+      raise browser_gone_exception.BrowserGoneException()
 
   def _ListTabs(self, timeout=None):
     if timeout:
diff --git a/tools/chrome_remote_control/chrome_remote_control/browser_credentials.py b/tools/chrome_remote_control/chrome_remote_control/browser_credentials.py
index 114a150f10615c..5155af913f2880 100644
--- a/tools/chrome_remote_control/chrome_remote_control/browser_credentials.py
+++ b/tools/chrome_remote_control/chrome_remote_control/browser_credentials.py
@@ -13,6 +13,7 @@ class BrowserCredentials(object):
   def __init__(self, backends = None):
     self._credentials = {}
     self._credentials_path = None
+    self._extra_credentials = {}
 
     if backends is None:
       backends = [
@@ -51,9 +52,17 @@ def credentials_path(self):
   @credentials_path.setter
   def credentials_path(self, credentials_path):
     self._credentials_path = credentials_path
-    self._ReadCredentialsFile()
+    self._RebuildCredentials()
 
-  def _ReadCredentialsFile(self):
+  def Add(self, credentials_type, data):
+    if credentials_type not in self._extra_credentials:
+      self._extra_credentials[credentials_type] = {}
+    for k, v in data.items():
+      assert k not in self._extra_credentials[credentials_type]
+      self._extra_credentials[credentials_type][k] = v
+    self._RebuildCredentials()
+
+  def _RebuildCredentials(self):
     credentials = {}
     if self._credentials_path == None:
       pass
@@ -73,10 +82,41 @@ def _ReadCredentialsFile(self):
         homedir_credentials = json.loads(f.read())
 
     self._credentials = {}
-    all_keys = set(credentials.keys()).union(homedir_credentials.keys())
+    all_keys = set(credentials.keys()).union(
+      homedir_credentials.keys()).union(
+      self._extra_credentials.keys())
+
     for k in all_keys:
       if k in credentials:
         self._credentials[k] = credentials[k]
       if k in homedir_credentials:
         logging.info("Will use ~/.crc-credentials for %s logins." % k)
         self._credentials[k] = homedir_credentials[k]
+      if k in self._extra_credentials:
+        self._credentials[k] = self._extra_credentials[k]
+
+  def WarnIfMissingCredentials(self, page_set):
+    num_pages_missing_login = 0
+    missing_credentials = set()
+    for page in page_set:
+      if (page.credentials
+          and not self.CanLogin(page.credentials)):
+        num_pages_missing_login += 1
+        missing_credentials.add(page.credentials)
+
+    if num_pages_missing_login > 0:
+      files_to_tweak = []
+      if page_set.credentials_path:
+        files_to_tweak.append(
+          os.path.relpath(os.path.join(page_set.base_dir,
+                                       page_set.credentials_path)))
+      files_to_tweak.append('~/.crc-credentials')
+
+      logging.warning("""
+        Credentials for %s were not found. %i pages will not be benchmarked.
+
+        To fix this, either add svn-internal to your .gclient using
+        http://goto/read-src-internal, or add your own credentials to
+%s""" % (', '.join(missing_credentials),
+       num_pages_missing_login,
+       ' or '.join(files_to_tweak)))
diff --git a/tools/chrome_remote_control/chrome_remote_control/browser_gone_exception.py b/tools/chrome_remote_control/chrome_remote_control/browser_gone_exception.py
new file mode 100644
index 00000000000000..56bf0122bfa998
--- /dev/null
+++ b/tools/chrome_remote_control/chrome_remote_control/browser_gone_exception.py
@@ -0,0 +1,9 @@
+# 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.
+class BrowserGoneException(Exception):
+  """Represnets a crash of the entire browser.
+
+  In this state, all bets are pretty much off."""
+  pass
+
diff --git a/tools/chrome_remote_control/chrome_remote_control/browser_options.py b/tools/chrome_remote_control/chrome_remote_control/browser_options.py
index e32d7de7f1ae01..1a06591031eeb8 100644
--- a/tools/chrome_remote_control/chrome_remote_control/browser_options.py
+++ b/tools/chrome_remote_control/chrome_remote_control/browser_options.py
@@ -8,6 +8,7 @@
 import logging
 
 from chrome_remote_control import browser_finder
+from chrome_remote_control import wpr_modes
 
 class BrowserOptions(optparse.Values):
   """Options to be used for discovering and launching a browser."""
@@ -26,6 +27,7 @@ def __init__(self, browser_type=None):
     self.show_stdout = False
 
     self.cros_remote = None
+    self.wpr_mode = wpr_modes.WPR_OFF
 
     self.verbosity = 0
 
@@ -83,8 +85,8 @@ def CreateParser(self, *args, **kwargs):
 
     # Page set options
     group = optparse.OptionGroup(parser, 'Page set options')
-    group.add_option('--record', action='store_true',
-        dest='record',
+    group.add_option('--record', action='store_const',
+        dest='wpr_mode', const=wpr_modes.WPR_RECORD,
         help='Record to the page set archive')
     parser.add_option_group(group)
 
diff --git a/tools/chrome_remote_control/chrome_remote_control/cros_browser_backend.py b/tools/chrome_remote_control/chrome_remote_control/cros_browser_backend.py
index 45ea71c3b2dbea..109f4c51e41c32 100644
--- a/tools/chrome_remote_control/chrome_remote_control/cros_browser_backend.py
+++ b/tools/chrome_remote_control/chrome_remote_control/cros_browser_backend.py
@@ -12,9 +12,8 @@
 class CrOSBrowserBackend(browser_backend.BrowserBackend):
   """The backend for controlling a browser instance running on CrOS.
   """
-  def __init__(self, browser_type, options, extra_browser_args,
-               is_content_shell, cri):
-    super(CrOSBrowserBackend, self).__init__(is_content_shell)
+  def __init__(self, browser_type, options, is_content_shell, cri):
+    super(CrOSBrowserBackend, self).__init__(is_content_shell, options)
     # Initialize fields so that an explosion during init doesn't break in Close.
     self._options = options
     assert not is_content_shell
@@ -26,6 +25,7 @@ def __init__(self, browser_type, options, extra_browser_args,
     self._port = tmp.getsockname()[1]
     tmp.close()
 
+    self._remote_debugging_port = self._cri.GetRemotePort()
     self._tmpdir = None
 
     self._X = None
@@ -39,20 +39,8 @@ def __init__(self, browser_type, options, extra_browser_args,
       logging.debug('stopping ui')
       self._cri.GetCmdOutput(['stop', 'ui'])
 
-    remote_port = self._cri.GetRemotePort()
-
-    args = ['/opt/google/chrome/chrome',
-            '--allow-webui-compositing',
-            '--aura-host-window-use-fullscreen',
-            '--enable-smooth-scrolling',
-            '--enable-threaded-compositing',
-            '--enable-per-tile-painting',
-            '--enable-gpu-sandboxing',
-            '--enable-accelerated-layers',
-            '--force-compositing-mode',
-            '--remote-debugging-port=%i' % remote_port,
-            '--start-maximized']
-
+    args = ['/opt/google/chrome/chrome']
+    args.extend(self.GetBrowserStartupArgs())
     if not is_content_shell:
       logging.info('Preparing user data dir')
       self._tmpdir = '/tmp/chrome_remote_control'
@@ -61,15 +49,9 @@ def __init__(self, browser_type, options, extra_browser_args,
         logging.critical('Feature not (yet) implemented.')
 
       # Ensure a clean user_data_dir.
-      self._cri.GetCmdOutput(['rm', '-rf', self._tmpdir])
-
-      args.append('--user-data-dir=%s' % self._tmpdir)
+      self._cri.RmRF(self._tmpdir)
 
     # Final bits of command line prep.
-    if extra_browser_args:
-      args.extend(extra_browser_args)
-    args.extend(options.extra_browser_args)
-    args.extend(self._common_chrome_browser_args)
     def EscapeIfNeeded(arg):
       return arg.replace(' ', '" "')
     args = [EscapeIfNeeded(arg) for arg in args]
@@ -103,7 +85,8 @@ def EscapeIfNeeded(arg):
       self._cri,
       args,
       prevent_output=prevent_output,
-      extra_ssh_args=['-L%i:localhost:%i' % (self._port, remote_port)],
+      extra_ssh_args=['-L%i:localhost:%i' % (
+          self._port, self._remote_debugging_port)],
       leave_ssh_alive=True,
       env={'DISPLAY': ':0',
            'USER': 'chronos'},
@@ -118,6 +101,25 @@ def EscapeIfNeeded(arg):
       self.Close()
       raise
 
+  def GetBrowserStartupArgs(self):
+    args = super(CrOSBrowserBackend, self).GetBrowserStartupArgs()
+
+    args.extend([
+            '--allow-webui-compositing',
+            '--aura-host-window-use-fullscreen',
+            '--enable-smooth-scrolling',
+            '--enable-threaded-compositing',
+            '--enable-per-tile-painting',
+            '--enable-gpu-sandboxing',
+            '--enable-accelerated-layers',
+            '--force-compositing-mode',
+            '--remote-debugging-port=%i' % self._remote_debugging_port,
+            '--start-maximized'])
+    if not self.is_content_shell:
+      args.append('--user-data-dir=%s' % self._tmpdir)
+
+    return args
+
   def __del__(self):
     self.Close()
 
@@ -131,7 +133,7 @@ def Close(self):
       self._X = None
 
     if self._tmpdir:
-      self._cri.GetCmdOutput(['rm', '-rf', self._tmpdir])
+      self._cri.RmRF(self._tmpdir)
       self._tmpdir = None
 
     self._cri = None
diff --git a/tools/chrome_remote_control/chrome_remote_control/cros_browser_finder.py b/tools/chrome_remote_control/chrome_remote_control/cros_browser_finder.py
index 2144500c08311a..6426e0ae7071b7 100644
--- a/tools/chrome_remote_control/chrome_remote_control/cros_browser_finder.py
+++ b/tools/chrome_remote_control/chrome_remote_control/cros_browser_finder.py
@@ -24,9 +24,9 @@ def __init__(self, browser_type, options, *args):
   def __repr__(self):
     return 'PossibleCrOSBrowser(browser_type=%s)' % self.browser_type
 
-  def Create(self, extra_browser_args=None):
+  def Create(self):
     backend = cros_browser_backend.CrOSBrowserBackend(
-        self.browser_type, self._options, extra_browser_args, *self._args)
+        self.browser_type, self._options, *self._args)
     return browser.Browser(backend)
 
 def FindAllAvailableBrowsers(options):
diff --git a/tools/chrome_remote_control/chrome_remote_control/cros_interface.py b/tools/chrome_remote_control/chrome_remote_control/cros_interface.py
index a6b5b95274e394..b03356f220cdd9 100644
--- a/tools/chrome_remote_control/chrome_remote_control/cros_interface.py
+++ b/tools/chrome_remote_control/chrome_remote_control/cros_interface.py
@@ -19,7 +19,7 @@
 # around pexpect, I suspect, if we wanted it to be faster. But, this was
 # convenient.
 
-def RunCmd(args, cwd=None):
+def RunCmd(args, cwd=None, quiet=False):
   """Opens a subprocess to execute a program and returns its return value.
 
   Args:
@@ -31,13 +31,14 @@ def RunCmd(args, cwd=None):
   Returns:
     Return code from the command execution.
   """
-  logging.debug(' '.join(args) + ' ' + (cwd or ''))
+  if not quiet:
+    logging.debug(' '.join(args) + ' ' + (cwd or ''))
   with open(os.devnull, 'w') as devnull:
     p = subprocess.Popen(args=args, cwd=cwd, stdout=devnull,
                          stderr=devnull, stdin=devnull, shell=False)
     return p.wait()
 
-def GetAllCmdOutput(args, cwd=None):
+def GetAllCmdOutput(args, cwd=None, quiet=False):
   """Open a subprocess to execute a program and returns its output.
 
   Args:
@@ -50,12 +51,14 @@ def GetAllCmdOutput(args, cwd=None):
     Captures and returns the command's stdout.
     Prints the command's stderr to logger (which defaults to stdout).
   """
-  logging.debug(' '.join(args) + ' ' + (cwd or ''))
+  if not quiet:
+    logging.debug(' '.join(args) + ' ' + (cwd or ''))
   with open(os.devnull, 'w') as devnull:
     p = subprocess.Popen(args=args, cwd=cwd, stdout=subprocess.PIPE,
                          stderr=subprocess.PIPE, stdin=devnull, shell=False)
     stdout, stderr = p.communicate()
-    logging.debug(' > stdout=[%s], stderr=[%s]', stdout, stderr)
+    if not quiet:
+      logging.debug(' > stdout=[%s], stderr=[%s]', stdout, stderr)
     return stdout, stderr
 
 class DeviceSideProcess(object):
@@ -78,7 +81,7 @@ def __init__(self,
     else:
       out = sys.stderr
 
-    cri.GetCmdOutput(['rm', '-rf', '/tmp/cros_interface_remote_device_pid'])
+    cri.RmRF('/tmp/cros_interface_remote_device_pid')
     cmd_str = ' '.join(device_side_args)
     if env:
       env_str = ' '.join(['%s=%s' % (k, v) for k, v in env.items()])
@@ -130,16 +133,18 @@ def Close(self, try_sigint_first=False):
     if self.IsAlive():
       # Try to politely shutdown, first.
       if try_sigint_first:
+        logging.debug("kill -INT %i" % self._pid)
         self._cri.GetAllCmdOutput(
-          ['kill', '-INT', str(self._pid)])
+          ['kill', '-INT', str(self._pid)], quiet=True)
         try:
           self.Wait(timeout=0.5)
         except util.TimeoutException:
           pass
 
       if self.IsAlive():
+        logging.debug("kill -KILL %i" % self._pid)
         self._cri.GetAllCmdOutput(
-          ['kill', '-KILL', str(self._pid)])
+          ['kill', '-KILL', str(self._pid)], quiet=True)
         try:
           self.Wait(timeout=5)
         except util.TimeoutException:
@@ -172,18 +177,21 @@ def IsDone():
     util.WaitFor(IsDone, timeout)
     self._pid = None
 
-  def IsAlive(self):
+  def IsAlive(self, quiet=True):
     if not self._pid:
       return False
-    exists = self._cri.FileExistsOnDevice('/proc/%i/cmdline' % self._pid)
+    exists = self._cri.FileExistsOnDevice('/proc/%i/cmdline' % self._pid,
+                                          quiet=quiet)
     return exists
 
 def HasSSH():
   try:
-    RunCmd(['ssh'])
-    RunCmd(['scp'])
+    RunCmd(['ssh'], quiet=True)
+    RunCmd(['scp'], quiet=True)
+    logging.debug("HasSSH()->True")
     return True
   except OSError:
+    logging.debug("HasSSH()->False")
     return False
 
 class LoginException(Exception):
@@ -222,11 +230,12 @@ def FormSSHCommandLine(self, args, extra_ssh_args=None):
     full_args.extend(args)
     return full_args
 
-  def GetAllCmdOutput(self, args, cwd=None):
-    return GetAllCmdOutput(self.FormSSHCommandLine(args), cwd)
+  def GetAllCmdOutput(self, args, cwd=None, quiet=False):
+    return GetAllCmdOutput(self.FormSSHCommandLine(args), cwd, quiet=quiet)
 
   def TryLogin(self):
-    stdout, stderr = self.GetAllCmdOutput(['echo', '$USER'])
+    logging.debug('TryLogin()')
+    stdout, stderr = self.GetAllCmdOutput(['echo', '$USER'], quiet=True)
 
     if stderr != '':
       if 'Host key verification failed' in stderr:
@@ -249,20 +258,25 @@ def TryLogin(self):
         'Logged into %s, expected $USER=root, but got %s.' % (
           self._hostname, stdout))
 
-  def FileExistsOnDevice(self, file_name):
+  def FileExistsOnDevice(self, file_name, quiet=False):
     stdout, stderr = self.GetAllCmdOutput([
         'if', 'test', '-a', file_name, ';',
         'then', 'echo', '1', ';',
         'fi'
-        ])
+        ], quiet=True)
     if stderr != '':
       if "Connection timed out" in stderr:
         raise OSError('Machine wasn\'t responding to ssh: %s' %
                       stderr)
       raise OSError('Unepected error: %s' % stderr)
-    return stdout == '1\n'
+    exists = stdout == '1\n'
+    if not quiet:
+      logging.debug("FileExistsOnDevice(<text>, %s)->%s" % (
+          file_name, exists))
+    return exists
 
   def PushContents(self, text, remote_filename):
+    logging.debug("PushContents(<text>, %s)" % remote_filename)
     with tempfile.NamedTemporaryFile() as f:
       f.write(text)
       f.flush()
@@ -278,7 +292,7 @@ def PushContents(self, text, remote_filename):
       args.extend([os.path.abspath(f.name),
                    'root@%s:%s' % (self._hostname, remote_filename)])
 
-      stdout, stderr = GetAllCmdOutput(args)
+      stdout, stderr = GetAllCmdOutput(args, quiet=True)
       if stderr != '':
         assert 'No such file or directory' in stderr
         raise OSError
@@ -297,20 +311,22 @@ def GetFileContents(self, filename):
       args.extend(['root@%s:%s' % (self._hostname, filename),
                    os.path.abspath(f.name)])
 
-      stdout, stderr = GetAllCmdOutput(args)
+      stdout, stderr = GetAllCmdOutput(args, quiet=True)
 
       if stderr != '':
         assert 'No such file or directory' in stderr
         raise OSError
 
       with open(f.name, 'r') as f2:
-        return f2.read()
+        res = f2.read()
+        logging.debug("GetFileContents(%s)->%s" % (filename, res))
+        return res
 
   def ListProcesses(self):
     stdout, stderr = self.GetAllCmdOutput([
         '/bin/ps', '--no-headers',
         '-A',
-        '-o', 'pid,args'])
+        '-o', 'pid,args'], quiet=True)
     assert stderr == ''
     procs = []
     for l in stdout.split('\n'): # pylint: disable=E1103
@@ -319,27 +335,37 @@ def ListProcesses(self):
       m = re.match('^\s*(\d+)\s+(.+)', l, re.DOTALL)
       assert m
       procs.append(m.groups())
+    logging.debug("ListProcesses(<predicate>)->[%i processes]" % len(procs))
     return procs
 
+  def RmRF(self, filename):
+    logging.debug("rm -rf %s" % filename)
+    self.GetCmdOutput(['rm', '-rf', filename], quiet=True)
+
   def KillAllMatching(self, predicate):
     kills = ['kill', '-KILL']
     for p in self.ListProcesses():
       if predicate(p[1]):
         logging.info('Killing %s', repr(p))
         kills.append(p[0])
+    logging.debug("KillAllMatching(<predicate>)->%i" % (len(kills) - 2))
     if len(kills) > 2:
-      self.GetCmdOutput(kills)
+      self.GetCmdOutput(kills, quiet=True)
     return len(kills) - 2
 
   def IsServiceRunning(self, service_name):
     stdout, stderr = self.GetAllCmdOutput([
-        'status', service_name])
+        'status', service_name], quiet=True)
     assert stderr == ''
-    return 'running, process' in stdout
+    running = 'running, process' in stdout
+    logging.debug("IsServiceRunning(%s)->%s" % (service_name, running))
+    return running
 
-  def GetCmdOutput(self, args):
-    stdout, stderr = self.GetAllCmdOutput(args)
+  def GetCmdOutput(self, args, quiet=False):
+    stdout, stderr = self.GetAllCmdOutput(args, quiet=True)
     assert stderr == ''
+    if not quiet:
+      logging.debug("GetCmdOutput(%s)->%s" % (repr(args), stdout))
     return stdout
 
   def GetRemotePort(self):
diff --git a/tools/chrome_remote_control/chrome_remote_control/desktop_browser_backend.py b/tools/chrome_remote_control/chrome_remote_control/desktop_browser_backend.py
index fec87a2bf41e02..ce9b3595d9878d 100644
--- a/tools/chrome_remote_control/chrome_remote_control/desktop_browser_backend.py
+++ b/tools/chrome_remote_control/chrome_remote_control/desktop_browser_backend.py
@@ -15,8 +15,8 @@ class DesktopBrowserBackend(browser_backend.BrowserBackend):
   """The backend for controlling a locally-executed browser instance, on Linux,
   Mac or Windows.
   """
-  def __init__(self, options, executable, is_content_shell, extra_browser_args):
-    super(DesktopBrowserBackend, self).__init__(is_content_shell)
+  def __init__(self, options, executable, is_content_shell):
+    super(DesktopBrowserBackend, self).__init__(is_content_shell, options)
 
     # Initialize fields so that an explosion during init doesn't break in Close.
     self._proc = None
@@ -28,16 +28,8 @@ def __init__(self, options, executable, is_content_shell, extra_browser_args):
       raise Exception('Cannot create browser, no executable found!')
 
     self._port = DEFAULT_PORT
-    args = [self._executable,
-            '--remote-debugging-port=%i' % self._port,
-            '--window-size=1280,1024']
-    if not options.dont_override_profile:
-      self._tmpdir = tempfile.mkdtemp()
-      args.append('--user-data-dir=%s' % self._tmpdir)
-    if extra_browser_args:
-      args.extend(extra_browser_args)
-    args.extend(options.extra_browser_args)
-    args.extend(self._common_chrome_browser_args)
+    args = [self._executable]
+    args.extend(self.GetBrowserStartupArgs())
     if not options.show_stdout:
       self._devnull = open(os.devnull, 'w')
       self._proc = subprocess.Popen(
@@ -52,6 +44,15 @@ def __init__(self, options, executable, is_content_shell, extra_browser_args):
       self.Close()
       raise
 
+  def GetBrowserStartupArgs(self):
+    args = super(DesktopBrowserBackend, self).GetBrowserStartupArgs()
+    args.append('--remote-debugging-port=%i' % self._port)
+    args.append('--window-size=1280,1024')
+    if not self.options.dont_override_profile:
+      self._tmpdir = tempfile.mkdtemp()
+      args.append('--user-data-dir=%s' % self._tmpdir)
+    return args
+
   def IsBrowserRunning(self):
     return self._proc.poll() == None
 
diff --git a/tools/chrome_remote_control/chrome_remote_control/desktop_browser_finder.py b/tools/chrome_remote_control/chrome_remote_control/desktop_browser_finder.py
index 77553a578d5828..32f91c899b47e8 100644
--- a/tools/chrome_remote_control/chrome_remote_control/desktop_browser_finder.py
+++ b/tools/chrome_remote_control/chrome_remote_control/desktop_browser_finder.py
@@ -32,10 +32,9 @@ def __init__(self, browser_type, options, executable, is_content_shell):
   def __repr__(self):
     return 'PossibleDesktopBrowser(browser_type=%s)' % self.browser_type
 
-  def Create(self, extra_browser_args=None):
+  def Create(self):
     backend = desktop_browser_backend.DesktopBrowserBackend(
-        self._options, self._local_executable, self._is_content_shell,
-        extra_browser_args)
+        self._options, self._local_executable, self._is_content_shell)
     return browser.Browser(backend)
 
 def FindAllAvailableBrowsers(options):
diff --git a/tools/chrome_remote_control/chrome_remote_control/inspector_console_unittest.py b/tools/chrome_remote_control/chrome_remote_control/inspector_console_unittest.py
index b6c9a5b9cf3398..134b250841a261 100644
--- a/tools/chrome_remote_control/chrome_remote_control/inspector_console_unittest.py
+++ b/tools/chrome_remote_control/chrome_remote_control/inspector_console_unittest.py
@@ -12,23 +12,25 @@ class TabConsoleTest(tab_test_case.TabTestCase):
   def testConsoleOutputStream(self):
     unittest_data_dir = os.path.join(os.path.dirname(__file__),
                                      '..', 'unittest_data')
-    with self._browser.CreateTemporaryHTTPServer(unittest_data_dir) as s:
-      stream = StringIO.StringIO()
-      self._tab.console.MessageOutputStream = stream
+    self._browser.SetHTTPServerDirectory(unittest_data_dir)
 
-      self._tab.page.Navigate(s.UrlOf('page_that_logs_to_console.html'))
-      self._tab.WaitForDocumentReadyStateToBeComplete()
+    stream = StringIO.StringIO()
+    self._tab.console.MessageOutputStream = stream
 
-      initial = self._tab.runtime.Evaluate('window.__logCount')
-      def GotLog():
-        current = self._tab.runtime.Evaluate('window.__logCount')
-        return current > initial
-      util.WaitFor(GotLog, 5)
+    self._tab.page.Navigate(
+      self._browser.http_server.UrlOf('page_that_logs_to_console.html'))
+    self._tab.WaitForDocumentReadyStateToBeComplete()
 
-      lines = [l for l in stream.getvalue().split('\n') if len(l)]
+    initial = self._tab.runtime.Evaluate('window.__logCount')
+    def GotLog():
+      current = self._tab.runtime.Evaluate('window.__logCount')
+      return current > initial
+    util.WaitFor(GotLog, 5)
 
-      self.assertTrue(len(lines) >= 1)
-      for l in lines:
-        u_l = 'http://localhost:(\d+)/page_that_logs_to_console.html:9'
-        self.assertTrue(re.match('At %s: Hello, world' % u_l, l))
+    lines = [l for l in stream.getvalue().split('\n') if len(l)]
+
+    self.assertTrue(len(lines) >= 1)
+    for l in lines:
+      u_l = 'http://localhost:(\d+)/page_that_logs_to_console.html:9'
+      self.assertTrue(re.match('At %s: Hello, world' % u_l, l))
 
diff --git a/tools/chrome_remote_control/chrome_remote_control/multi_page_benchmark_unittest.py b/tools/chrome_remote_control/chrome_remote_control/multi_page_benchmark_unittest.py
index e958380ffe1463..a90251861183be 100644
--- a/tools/chrome_remote_control/chrome_remote_control/multi_page_benchmark_unittest.py
+++ b/tools/chrome_remote_control/chrome_remote_control/multi_page_benchmark_unittest.py
@@ -5,7 +5,9 @@
 
 from chrome_remote_control import multi_page_benchmark
 from chrome_remote_control import multi_page_benchmark_unittest_base
+from chrome_remote_control import page as page_module
 from chrome_remote_control import page_set
+from chrome_remote_control import wpr_modes
 
 class BenchThatFails(multi_page_benchmark.MultiPageBenchmark):
   def MeasurePage(self, page, tab, results):
@@ -34,10 +36,10 @@ def MeasurePage(self, page, tab, results):
 class MultiPageBenchmarkUnitTest(
   multi_page_benchmark_unittest_base.MultiPageBenchmarkUnitTestBase):
 
-  _record = False
+  _wpr_mode = wpr_modes.WPR_OFF
 
   def CustomizeOptionsForTest(self, options):
-    options.record = self._record
+    options.wpr_mode = self._wpr_mode
 
   def testGotToBlank(self):
     ps = self.CreatePageSetFromFileInUnittestDataDir('blank.html')
@@ -66,20 +68,20 @@ def testRecordAndReplay(self):
       benchmark = BenchForReplay()
 
       # First record an archive with only www.google.com.
-      self._record = True
+      self._wpr_mode = wpr_modes.WPR_RECORD
 
-      ps.pages = [page_set.Page('http://www.google.com/')]
+      ps.pages = [page_module.Page('http://www.google.com/')]
       all_results = self.RunBenchmark(benchmark, ps)
       self.assertEquals(0, len(all_results.page_failures))
 
       # Now replay it and verify that google.com is found but foo.com is not.
-      self._record = False
+      self._wpr_mode = wpr_modes.WPR_REPLAY
 
-      ps.pages = [page_set.Page('http://www.foo.com/')]
+      ps.pages = [page_module.Page('http://www.foo.com/')]
       all_results = self.RunBenchmark(benchmark, ps)
       self.assertEquals(1, len(all_results.page_failures))
 
-      ps.pages = [page_set.Page('http://www.google.com/')]
+      ps.pages = [page_module.Page('http://www.google.com/')]
       all_results = self.RunBenchmark(benchmark, ps)
       self.assertEquals(0, len(all_results.page_failures))
 
diff --git a/tools/chrome_remote_control/chrome_remote_control/multi_page_benchmark_unittest_base.py b/tools/chrome_remote_control/chrome_remote_control/multi_page_benchmark_unittest_base.py
index 07ff178f6b7c24..3ceb69db60ed12 100644
--- a/tools/chrome_remote_control/chrome_remote_control/multi_page_benchmark_unittest_base.py
+++ b/tools/chrome_remote_control/chrome_remote_control/multi_page_benchmark_unittest_base.py
@@ -8,6 +8,7 @@
 from chrome_remote_control import multi_page_benchmark
 from chrome_remote_control import options_for_unittests
 from chrome_remote_control import page_runner
+from chrome_remote_control import page as page_module
 from chrome_remote_control import page_set
 
 class MultiPageBenchmarkUnitTestBase(unittest.TestCase):
@@ -21,7 +22,7 @@ def CreatePageSetFromFileInUnittestDataDir(self, test_filename):
     path = os.path.join(self.unittest_data_dir, test_filename)
     self.assertTrue(os.path.exists(path))
 
-    page = page_set.Page('file://%s' % test_filename)
+    page = page_module.Page('file://%s' % test_filename)
 
     ps = page_set.PageSet(base_dir=self.unittest_data_dir)
     ps.pages.append(page)
diff --git a/tools/chrome_remote_control/chrome_remote_control/page.py b/tools/chrome_remote_control/chrome_remote_control/page.py
new file mode 100644
index 00000000000000..e966777f936db9
--- /dev/null
+++ b/tools/chrome_remote_control/chrome_remote_control/page.py
@@ -0,0 +1,23 @@
+# 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.
+import urlparse
+
+class Page(object):
+  def __init__(self, url, attributes=None):
+    self.url = url
+    parsed_url = urlparse.urlparse(url)
+    if parsed_url.scheme == None: # pylint: disable=E1101
+      raise Exception('urls must be fully qualified: %s' % url)
+    self.interactions = 'scroll'
+    self.credentials = None
+    self.wait_time_after_navigate = 2
+    self.scroll_is_infinite = False
+    self.wait_for_javascript_expression = None
+
+    if attributes:
+      for k, v in attributes.iteritems():
+        setattr(self, k, v)
+
+  def __str__(self):
+    return self.url
diff --git a/tools/chrome_remote_control/chrome_remote_control/page_runner.py b/tools/chrome_remote_control/chrome_remote_control/page_runner.py
index df0374f296e0b4..f04dfffe9c6049 100644
--- a/tools/chrome_remote_control/chrome_remote_control/page_runner.py
+++ b/tools/chrome_remote_control/chrome_remote_control/page_runner.py
@@ -7,11 +7,9 @@
 import traceback
 import urlparse
 
-from chrome_remote_control import browser
-from chrome_remote_control import options_for_unittests
 from chrome_remote_control import page_test
-from chrome_remote_control import replay_server
 from chrome_remote_control import util
+from chrome_remote_control import wpr_modes
 
 class PageState(object):
   def __init__(self):
@@ -21,10 +19,6 @@ class PageRunner(object):
   """Runs a given test against a given test."""
   def __init__(self, page_set):
     self.page_set = page_set
-    self._server = None
-
-  def __del__(self):
-    assert self._server == None
 
   def __enter__(self):
     return self
@@ -35,11 +29,11 @@ def __exit__(self, *args):
   def Run(self, options, possible_browser, test, results):
     archive_path = os.path.abspath(os.path.join(self.page_set.base_dir,
                                                 self.page_set.archive_path))
-    if browser.Browser.CanUseReplayServer(archive_path, options.record):
-      extra_browser_args = replay_server.CHROME_FLAGS
-    else:
-      extra_browser_args = []
-      if not options_for_unittests.Get():
+    if options.wpr_mode == wpr_modes.WPR_OFF:
+      if os.path.isfile(archive_path):
+        possible_browser.options.wpr_mode = wpr_modes.WPR_REPLAY
+      else:
+        possible_browser.options.wpr_mode = wpr_modes.WPR_OFF
         logging.warning("""
 The page set archive %s does not exist, benchmarking against live sites!
 Results won't be repeatable or comparable.
@@ -55,40 +49,16 @@ def Run(self, options, possible_browser, test, results):
       if not os.path.exists(credentials_path):
         credentials_path = None
 
-    with possible_browser.Create(extra_browser_args) as b:
+    with possible_browser.Create() as b:
       b.credentials.credentials_path = credentials_path
       test.SetUpBrowser(b)
 
-      self._WarnAboutCredentialsIfNeeded(b)
-
-      with b.CreateReplayServer(archive_path, options.record):
-        with b.ConnectToNthTab(0) as tab:
-          for page in self.page_set:
-            self._RunPage(options, page, tab, test, results)
-
-  def _WarnAboutCredentialsIfNeeded(self, b):
-    num_pages_missing_login = 0
-    missing_credentials = set()
-    for page in self.page_set:
-      if page.credentials and not b.credentials.CanLogin(page.credentials):
-        num_pages_missing_login += 1
-        missing_credentials.add(page.credentials)
-    if num_pages_missing_login > 0:
-      files_to_tweak = []
-      if self.page_set.credentials_path:
-        files_to_tweak.append(
-          os.path.relpath(os.path.join(self.page_set.base_dir,
-                                       self.page_set.credentials_path)))
-      files_to_tweak.append('~/.crc-credentials')
-
-      logging.warning("""
-Credentials for %s were not found. %i pages will not be benchmarked.
+      b.credentials.WarnIfMissingCredentials(self.page_set)
 
-To fix this, either add svn-internal to your .gclient using
-http://goto/read-src-internal, or add your own credentials to
-%s""" % (', '.join(missing_credentials),
-       num_pages_missing_login,
-       ' or '.join(files_to_tweak)))
+      b.SetReplayArchivePath(archive_path)
+      with b.ConnectToNthTab(0) as tab:
+        for page in self.page_set:
+          self._RunPage(options, page, tab, test, results)
 
   def _RunPage(self, options, page, tab, test, results):
     logging.info('Running %s' % page.url)
@@ -124,9 +94,7 @@ def _RunPage(self, options, page, tab, test, results):
       self.CleanUpPage(page, tab, page_state)
 
   def Close(self):
-    if self._server:
-      self._server.Close()
-      self._server = None
+    pass
 
   @staticmethod
   def WaitForPageToLoad(expression, tab):
@@ -142,29 +110,29 @@ def PreparePage(self, page, tab, page_state, results):
       path = os.path.join(self.page_set.base_dir,
                           parsed_url.netloc) # pylint: disable=E1101
       dirname, filename = os.path.split(path)
-      if self._server and self._server.path != dirname:
-        self._server.Close()
-        self._server = None
-      if not self._server:
-        self._server = tab.browser.CreateTemporaryHTTPServer(dirname)
-      page.url = self._server.UrlOf(filename)
+      tab.browser.SetHTTPServerDirectory(dirname)
+      target_side_url = tab.browser.http_server.UrlOf(filename)
+    else:
+      target_side_url = page.url
 
     if page.credentials:
       page_state.did_login = tab.browser.credentials.LoginNeeded(
         tab, page.credentials)
       if not page_state.did_login:
-        msg = 'Could not login to %s on %s' % (page.credentials, page.url)
+        msg = 'Could not login to %s on %s' % (page.credentials,
+                                               target_side_url)
         logging.info(msg)
         results.AddFailure(page, msg, "")
         return False
 
-    tab.page.Navigate(page.url)
-    # TODO(dtu): Detect HTTP redirects.
+    tab.page.Navigate(target_side_url)
+
+    # Wait for unpredictable redirects.
     if page.wait_time_after_navigate:
-      # Wait for unpredictable redirects.
       time.sleep(page.wait_time_after_navigate)
     if page.wait_for_javascript_expression is not None:
       self.WaitForPageToLoad(page.wait_for_javascript_expression, tab)
+
     tab.WaitForDocumentReadyStateToBeInteractiveOrBetter()
     return True
 
diff --git a/tools/chrome_remote_control/chrome_remote_control/page_runner_unittest.py b/tools/chrome_remote_control/chrome_remote_control/page_runner_unittest.py
index f90d4c89b73da7..5b29633f9cd1e2 100644
--- a/tools/chrome_remote_control/chrome_remote_control/page_runner_unittest.py
+++ b/tools/chrome_remote_control/chrome_remote_control/page_runner_unittest.py
@@ -5,6 +5,7 @@
 import unittest
 
 from chrome_remote_control import browser_finder
+from chrome_remote_control import page as page_module
 from chrome_remote_control import page_set
 from chrome_remote_control import page_test
 from chrome_remote_control import page_runner
@@ -58,7 +59,7 @@ def testCredentialsWhenLoginSucceeds(self):
   def runCredentialsTest(self, # pylint: disable=R0201
                          credentials_backend,
                          results):
-    page = page_set.Page('http://www.google.com')
+    page = page_module.Page('http://www.google.com')
     page.credentials = "test"
     ps = page_set.PageSet()
     ps.pages.append(page)
diff --git a/tools/chrome_remote_control/chrome_remote_control/page_set.py b/tools/chrome_remote_control/chrome_remote_control/page_set.py
index c5400cc09212e7..adc127dc166c15 100644
--- a/tools/chrome_remote_control/chrome_remote_control/page_set.py
+++ b/tools/chrome_remote_control/chrome_remote_control/page_set.py
@@ -2,28 +2,9 @@
 # Use of this source code is governed by a BSD-style license that can be
 # found in the LICENSE file.
 import json
-import urlparse
 import os
 
-class Page(object):
-  def __init__(self, url, attributes=None):
-    self.url = url
-    parsed_url = urlparse.urlparse(url)
-    if parsed_url.scheme == None: # pylint: disable=E1101
-      raise Exception('urls must be fully qualified: %s' % url)
-    self.interactions = 'scroll'
-    self.credentials = None
-    self.is_gmail = False
-    self.wait_time_after_navigate = 2
-    self.scroll_is_infinite = False
-    self.wait_for_javascript_expression = None
-
-    if attributes:
-      for k, v in attributes.iteritems():
-        setattr(self, k, v)
-
-  def __str__(self):
-    return self.url
+from chrome_remote_control import page as page_module
 
 class PageSet(object):
   def __init__(self, base_dir='', attributes=None):
@@ -50,7 +31,7 @@ def FromDict(cls, data, file_path=''):
     page_set = cls(file_path, data)
     for page_attributes in data['pages']:
       url = page_attributes.pop('url')
-      page = Page(url, page_attributes)
+      page = page_module.Page(url, page_attributes)
       page_set.pages.append(page)
     return page_set
 
diff --git a/tools/chrome_remote_control/chrome_remote_control/possible_browser.py b/tools/chrome_remote_control/chrome_remote_control/possible_browser.py
index 6eb99a672d8c7f..2cb995fea58d41 100644
--- a/tools/chrome_remote_control/chrome_remote_control/possible_browser.py
+++ b/tools/chrome_remote_control/chrome_remote_control/possible_browser.py
@@ -14,5 +14,9 @@ def __init__(self, browser_type, options):
   def __repr__(self):
     return 'PossibleBrowser(browser_type=%s)' % self.browser_type
 
-  def Create(self, extra_browser_args=None):
+  @property
+  def options(self):
+    return self._options
+
+  def Create(self):
     raise NotImplementedError()
diff --git a/tools/chrome_remote_control/chrome_remote_control/run_tests.py b/tools/chrome_remote_control/chrome_remote_control/run_tests.py
index ed44b2018b7bc4..e09550728cb285 100644
--- a/tools/chrome_remote_control/chrome_remote_control/run_tests.py
+++ b/tools/chrome_remote_control/chrome_remote_control/run_tests.py
@@ -116,6 +116,9 @@ def Main(args, start_dir, top_level_dir):
 
   _, args = parser.parse_args(args)
 
+  if default_options.verbosity == 0:
+    logging.getLogger().setLevel(logging.ERROR)
+
   from chrome_remote_control import browser_finder
   browser_to_create = browser_finder.FindBrowser(default_options)
   if browser_to_create == None:
diff --git a/tools/chrome_remote_control/chrome_remote_control/temporary_http_server.py b/tools/chrome_remote_control/chrome_remote_control/temporary_http_server.py
index 5335d2ff50701c..952f942ee8c614 100644
--- a/tools/chrome_remote_control/chrome_remote_control/temporary_http_server.py
+++ b/tools/chrome_remote_control/chrome_remote_control/temporary_http_server.py
@@ -31,6 +31,10 @@ def __init__(self, browser_backend, path):
 
     self._forwarder = browser_backend.CreateForwarder(self._host_port)
 
+  @property
+  def path(self):
+    return self._path
+
   def __enter__(self):
     return self
 
@@ -51,10 +55,6 @@ def Close(self):
       self._devnull.close()
       self._devnull = None
 
-  @property
-  def path(self):
-    return self._path
-
   @property
   def url(self):
     return self._forwarder.url
diff --git a/tools/chrome_remote_control/chrome_remote_control/temporary_http_server_unittest.py b/tools/chrome_remote_control/chrome_remote_control/temporary_http_server_unittest.py
index eeb05448c449d0..62cf65fb606852 100644
--- a/tools/chrome_remote_control/chrome_remote_control/temporary_http_server_unittest.py
+++ b/tools/chrome_remote_control/chrome_remote_control/temporary_http_server_unittest.py
@@ -14,12 +14,12 @@ def testBasicHosting(self):
     options = options_for_unittests.Get()
     browser_to_create = browser_finder.FindBrowser(options)
     with browser_to_create.Create() as b:
-      with b.CreateTemporaryHTTPServer(unittest_data_dir) as s:
-        with b.ConnectToNthTab(0) as t:
-          t.page.Navigate(s.UrlOf('/blank.html'))
-          t.WaitForDocumentReadyStateToBeComplete()
-          x = t.runtime.Evaluate('document.body.innerHTML')
-          x = x.strip()
+      b.SetHTTPServerDirectory(unittest_data_dir)
+      with b.ConnectToNthTab(0) as t:
+        t.page.Navigate(b.http_server.UrlOf('/blank.html'))
+        t.WaitForDocumentReadyStateToBeComplete()
+        x = t.runtime.Evaluate('document.body.innerHTML')
+        x = x.strip()
 
-          self.assertEquals(x, 'Hello world')
+        self.assertEquals(x, 'Hello world')
 
diff --git a/tools/chrome_remote_control/chrome_remote_control/wpr_modes.py b/tools/chrome_remote_control/chrome_remote_control/wpr_modes.py
new file mode 100644
index 00000000000000..64ffe08853cafe
--- /dev/null
+++ b/tools/chrome_remote_control/chrome_remote_control/wpr_modes.py
@@ -0,0 +1,7 @@
+# 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.
+WPR_OFF = 'wpr-off'
+WPR_RECORD = 'wpr-record'
+WPR_REPLAY = 'wpr-replay'
+
diff --git a/tools/chrome_remote_control/chrome_remote_control/replay_server.py b/tools/chrome_remote_control/chrome_remote_control/wpr_server.py
similarity index 86%
rename from tools/chrome_remote_control/chrome_remote_control/replay_server.py
rename to tools/chrome_remote_control/chrome_remote_control/wpr_server.py
index 962aa63ff4aab8..1abf92792aecbb 100644
--- a/tools/chrome_remote_control/chrome_remote_control/replay_server.py
+++ b/tools/chrome_remote_control/chrome_remote_control/wpr_server.py
@@ -40,8 +40,6 @@ def __exit__(self, *args):
     self.Close()
 
   def Close(self):
-    if self._browser_backend:
-      self._browser_backend.Close()
     if self._http_forwarder:
       self._http_forwarder.Close()
       self._http_forwarder = None
@@ -51,13 +49,3 @@ def Close(self):
     if self._web_page_replay:
       self._web_page_replay.StopServer()
       self._web_page_replay = None
-
-class DoNothingReplayServer(object):
-  def __init__(self, browser_backend, path, is_record_mode):
-    pass
-
-  def __enter__(self):
-    return self
-
-  def __exit__(self, *args):
-    pass