Move url_open with dependencies to utils.net module.

tests/url_open_timeout_test.py

 #!/usr/bin/env python
 # Copyright 2013 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 BaseHTTPServer
 import logging
 import os
 import re
 import SocketServer
 import sys
 import threading
 import time
 import unittest
 
 ROOT_DIR = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
 sys.path.insert(0, ROOT_DIR)
 
-import run_isolated
+from utils import net
 
 
 class SleepingServer(SocketServer.ThreadingMixIn, BaseHTTPServer.HTTPServer):
   """Multithreaded server that serves requests that block at various stages."""
 
   def __init__(self):
     BaseHTTPServer.HTTPServer.__init__(self, ('127.0.0.1', 0), SleepingHandler)
     self.dying = False
     self.dying_cv = threading.Condition()
     self.serving_thread = None
@@ skipping 85 matching lines @@
     self.server.start()
 
   def tearDown(self):
     self.server.stop()
     self.server = None
     super(UrlOpenTimeoutTest, self).tearDown()
 
   def call(self, mode, sleep_duration, **kwargs):
     url = self.server.url + '/%s/%f' % (mode, sleep_duration)
     kwargs['max_attempts'] = 2
-    return run_isolated.url_open(url, **kwargs)
+    return net.url_open(url, **kwargs)
 
   def test_urlopen_success(self):
     # Server doesn't block.
     for mode in SleepingHandler.modes:
       self.assertEqual(self.call(mode, 0, read_timeout=0.1).read(),
                        SleepingHandler.full_response)
     # Server does block, but url_open called without read timeout.
     for mode in SleepingHandler.modes:
       self.assertEqual(self.call(mode, 0.25, read_timeout=None).read(),
                        SleepingHandler.full_response)
 
   def test_urlopen_retry(self):
     # This should trigger retry logic and eventually return None.
-    prev_sleep_before_retry = run_isolated.HttpService.sleep_before_retry
+    prev_sleep_before_retry = net.HttpService.sleep_before_retry
     try:
-      run_isolated.HttpService.sleep_before_retry = lambda *_args: None
+      net.HttpService.sleep_before_retry = lambda *_args: None
       stream = self.call('sleep_before_response', 0.25, read_timeout=0.1)
     finally:
-      run_isolated.HttpService.sleep_before_retry = prev_sleep_before_retry
+      net.HttpService.sleep_before_retry = prev_sleep_before_retry
     self.assertIsNone(stream)
 
   def test_urlopen_keeping_connection(self):
     # Sleeping after request is sent -> it's just connection keep alive.
     stream = self.call('sleep_after_response', 0.25, read_timeout=0.1)
     self.assertEqual(stream.read(), SleepingHandler.full_response)
 
   def test_urlopen_timeouts(self):
     # Timeouts while reading from the stream.
     for mode in ('sleep_after_headers', 'sleep_during_response'):
       stream = self.call(mode, 0.25, read_timeout=0.1)
       self.assertTrue(stream)
-      with self.assertRaises(run_isolated.TimeoutError):
+      with self.assertRaises(net.TimeoutError):
         stream.read()
 
 
 if __name__ == '__main__':
   VERBOSE = '-v' in sys.argv
   logging.basicConfig(level=logging.DEBUG if VERBOSE else logging.ERROR)
   unittest.main()