[Chromedriver] Add Device Metrics override support to ChromeDriver via Capabilities

chrome/test/chromedriver/test/webserver.py

 # 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 os
 import threading
 
 
 class Responder(object):
@@ skipping 30 matching lines @@
 
 class Request(object):
   """An HTTP request."""
 
   def __init__(self, handler):
     self._handler = handler
 
   def GetPath(self):
     return self._handler.path
 
+  def GetHeader(self, name):
+    return self._handler.headers.getheader(name)
+
 
 class _BaseServer(BaseHTTPServer.HTTPServer):
   """Internal server that throws if timed out waiting for a request."""
 
   def __init__(self, on_request, server_cert_and_key_path=None):
     """Starts the server.
 
     It is an HTTP server if parameter server_cert_and_key_path is not provided.
     Otherwise, it is an HTTPS server.
 
@@ skipping 52 matching lines @@
       root_dir: root path to serve files from. This parameter is required.
       server_cert_and_key_path: path to a PEM file containing the cert and key.
                                 if it is None, start the server as an HTTP one.
     """
     self._root_dir = os.path.abspath(root_dir)
     self._server = _BaseServer(self._OnRequest, server_cert_and_key_path)
     self._thread = threading.Thread(target=self._server.serve_forever)
     self._thread.daemon = True
     self._thread.start()
     self._path_data_map = {}
-    self._path_data_lock = threading.Lock()
+    self._path_callback_map = {}
+    self._path_maps_lock = threading.Lock()
 
   def _OnRequest(self, request, responder):
     path = request.GetPath().split('?')[0]
 
-    # Serve from path -> data map.
-    self._path_data_lock.acquire()
+    # Serve from path -> callback and data maps.
+    self._path_maps_lock.acquire()
     try:
+      if path in self._path_callback_map:
+        body = self._path_callback_map[path](request)
+        if body:
+          responder.SendResponse(body)
+        else:
+          responder.SendError(503)
+        return
+
       if path in self._path_data_map:
         responder.SendResponse(self._path_data_map[path])
         return
     finally:
-      self._path_data_lock.release()
+      self._path_maps_lock.release()
 
     # Serve from file.
     path = os.path.normpath(
         os.path.join(self._root_dir, *path.split('/')))
     if not path.startswith(self._root_dir):
       responder.SendError(403)
       return
     if not os.path.exists(path):
       responder.SendError(404)
       return
     responder.SendResponseFromFile(path)
 
   def SetDataForPath(self, path, data):
-    self._path_data_lock.acquire()
+    self._path_maps_lock.acquire()
     try:
       self._path_data_map[path] = data
     finally:
-      self._path_data_lock.release()
+      self._path_maps_lock.release()
+
+  def SetCallbackForPath(self, path, func):
+    self._path_maps_lock.acquire()
+    try:
+      self._path_callback_map[path] = func
+    finally:
+      self._path_maps_lock.release()
+
 
   def GetUrl(self):
     """Returns the base URL of the server."""
     return self._server.GetUrl()
 
   def Shutdown(self):
     """Shuts down the server synchronously."""
     self._server.shutdown()
     self._thread.join()
 
@@ skipping 32 matching lines @@
       self._server.handle_request()
 
   def RespondWithContent(self, content):
     """Blocks until request comes in, then handles it with the given content."""
     def SendContent(responder):
       responder.SendResponse(content)
     self.Respond(SendContent)
 
   def GetUrl(self):
     return self._server.GetUrl()