Add command-line option for Virtual Me2Me to set the desktop size.

remoting/tools/me2me_virtual_host.py

 #!/usr/bin/env python
 # Copyright (c) 2011 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.
 
 # Virtual Me2Me implementation.  This script runs and manages the processes
 # required for a Virtual Me2Me desktop, which are: X server, X desktop
 # session, and Host process.
 # This script is intended to run continuously as a background daemon
 # process, running under an ordinary (non-root) user account.
 
 import atexit
 import getpass
 import hashlib
 import json
 import logging
+import optparse
 import os
 import random
 import signal
 import socket
 import subprocess
 import sys
 import time
 import urllib2
 import uuid
 
@@ skipping 167 matching lines @@
       logging.info("Terminating Xvfb")
       desktop.x_proc.terminate()
 
 def signal_handler(signum, stackframe):
     # Exit cleanly so the atexit handler, cleanup(), gets called.
     raise SystemExit
 
 
 class Desktop:
   """Manage a single virtual desktop"""
-  def __init__(self):
+  def __init__(self, width, height):
     self.x_proc = None
+    self.width = width
+    self.height = height
     g_desktops.append(self)
 
   @staticmethod
   def get_unused_display_number():
     """Return a candidate display number for which there is currently no
     X Server lock file"""
     display = FIRST_X_DISPLAY_NUMBER
     while os.path.exists(X_LOCK_FILE_TEMPLATE % display):
       display += 1
     return display
 
   def launch_x_server(self):
     display = self.get_unused_display_number()
     ret_code = subprocess.call("xauth add :%d . `mcookie`" % display,
                                shell=True)
     if ret_code != 0:
       raise Exception("xauth failed with code %d" % ret_code)
 
     logging.info("Starting Xvfb on display :%d" % display);
+    screen_option = "%dx%dx24" % (self.width, self.height)
     self.x_proc = subprocess.Popen(["Xvfb", ":%d" % display,
                                     "-auth", X_AUTH_FILE,
                                     "-nolisten", "tcp",
-                                    "-screen", "0", "1024x768x24",
+                                    "-screen", "0", screen_option
                                     ])
     if not self.x_proc.pid:
       raise Exception("Could not start Xvfb.")
 
     # Create clean environment for new session, so it is cleanly separated from
     # the user's console X session.
     self.child_env = {"DISPLAY": ":%d" % display}
     for key in [
         "HOME",
         "LOGNAME",
@@ skipping 28 matching lines @@
   def launch_host(self, host):
     # Start remoting host
     args = [locate_executable(REMOTING_COMMAND),
             "--%s=%s" % (HOST_CONFIG_SWITCH_NAME, host.config_file)]
     self.host_proc = subprocess.Popen(args, env=self.child_env)
     if not self.host_proc.pid:
       raise Exception("Could not start remoting host")
 
 
 def main():
+  parser = optparse.OptionParser()
+  parser.add_option("-s", "--size", dest="size", default="1280x1024",
+                    help="dimensions of virtual desktop (default: %default)")
+  (options, args) = parser.parse_args()
+
+  size_components = options.size.split("x")
+  if len(size_components) != 2:
+    parser.error("Incorrect size format, should be WIDTHxHEIGHT");
+
+  try:
+    width = int(size_components[0])
+    height = int(size_components[1])
+
+    # Enforce minimum desktop size, as a sanity-check.  The limit of 100 will
+    # detect typos of 2 instead of 3 digits.
+    if width < 100 or height < 100:
+      raise ValueError
+  except ValueError:
+    parser.error("Dimensions should be 100 pixels or greater")

[Wez, 2011/12/13 01:43:52]

nit: I'd actually use "Width and height" rather than "Dimensions" here.

+
   atexit.register(cleanup)
 
   for s in [signal.SIGHUP, signal.SIGINT, signal.SIGTERM]:
     signal.signal(s, signal_handler)
 
   # Ensure full path to config directory exists.
   if not os.path.exists(CONFIG_DIR):
     os.makedirs(CONFIG_DIR, mode=0700)
 
   auth = Authentication(os.path.join(CONFIG_DIR, "auth.json"))
   if not auth.load_config():
     try:
       auth.refresh_tokens()
     except:
       logging.error("Authentication failed.")
       return 1
     auth.save_config()
 
   host_hash = hashlib.md5(socket.gethostname()).hexdigest()
   host = Host(os.path.join(CONFIG_DIR, "host#%s.json" % host_hash))
 
   if not host.load_config():
     host.create_config(auth)
     host.save_config()
 
   logging.info("Using host_id: " + host.host_id)
 
-  desktop = Desktop()
+  desktop = Desktop(width, height)
   desktop.launch_x_server()
   desktop.launch_x_session()
   desktop.launch_host(host)
 
   while True:
     pid, status = os.wait()
     logging.info("wait() returned (%s,%s)" % (pid, status))
 
     if pid == desktop.x_proc.pid:
       logging.info("X server process terminated with code %d", status)
       break
 
     if pid == desktop.host_proc.pid:
       logging.info("Host process terminated, relaunching")
       desktop.launch_host(host)
 
 if __name__ == "__main__":
   logging.basicConfig(level=logging.DEBUG)
   sys.exit(main())