Fix rebaseline-o-matic logging

Tools/Scripts/webkitpy/tool/commands/rebaseline.py

 # Copyright (c) 2010 Google Inc. All rights reserved.
 #
 # Redistribution and use in source and binary forms, with or without
 # modification, are permitted provided that the following conditions are
 # met:
 #
 #     * Redistributions of source code must retain the above copyright
 # notice, this list of conditions and the following disclaimer.
 #     * Redistributions in binary form must reproduce the above
 # copyright notice, this list of conditions and the following disclaimer
@@ skipping 744 matching lines @@
                 lines_to_remove[test].append(builder_name)
                 test_prefix_list[test][builder_name] = BASELINE_SUFFIX_LIST
 
         return test_prefix_list, lines_to_remove
 
     def _run_git_cl_command(self, options, command):
         subprocess_command = ['git', 'cl'] + command
         if options.verbose:
             subprocess_command.append('--verbose')
 
-        process = self._tool.executive.popen(subprocess_command, stdout=self._tool.executive.PIPE, stderr=self._tool.executive.PIPE)
+        process = self._tool.executive.popen(subprocess_command, stdout=self._tool.executive.PIPE, stderr=self._tool.executive.STDOUT)
         last_output_time = time.time()
 
         # git cl sometimes completely hangs. Bail if we haven't gotten any output to stdout/stderr in a while.
         while process.poll() == None and time.time() < last_output_time + self.SECONDS_BEFORE_GIVING_UP:
-            # FIXME: This isn't awesome. It may improperly interleave stdout and stderr?
+            # FIXME: This doesn't make any sense. readline blocks, so all this code to
+            # try and bail is useless. Instead, we should do the readline calls on a
+            # subthread. Then the rest of this code would make sense.
             out = process.stdout.readline().rstrip('\n')
             if out:
                 last_output_time = time.time()
                 _log.info(out)
 
-            err = process.stdout.readline().rstrip('\n')
-            if err:
-                last_output_time = time.time()
-                _log.error(err)
-
         if process.poll() == None:
             _log.error('Command hung: %s' % subprocess_command)
             return False
         return True
 
     # FIXME: Move this somewhere more general.
     def tree_status(self):
         blink_tree_status_url = "http://blink-status.appspot.com/status"
         status = urllib2.urlopen(blink_tree_status_url).read().lower()
         if status.find('closed') != -1 or status == "0":
@@ skipping 87 matching lines @@
         urllib2.urlopen("http://" + self.LOG_SERVER + "/updatelog", data=urllib.urlencode(query))
 
     def _log_line(self, handle):
         out = handle.readline().rstrip('\n')
         if out:
             if self._verbose:
                 print out
             self._log_to_server(out)
         return out
 
-    def _log_remaining_lines(self, handle):
-        out = self._log_line(handle)
+    def _run_logged_command(self, command):
+        process = self._tool.executive.popen(command, stdout=self._tool.executive.PIPE, stderr=self._tool.executive.STDOUT)
+
+        out = self._log_line(process.stdout)
         while out:
-            out = self._log_line(handle)
-
-    def _run_logged_command(self, command):
-        process = self._tool.executive.popen(command, stdout=self._tool.executive.PIPE, stderr=self._tool.executive.PIPE)
-        while process.poll() == None:
             # FIXME: This should probably batch up lines if they're available and log to the server once.
-            self._log_line(process.stdout)
-            self._log_line(process.stderr)
-
-        self._log_remaining_lines(process.stdout)
-        self._log_remaining_lines(process.stderr)
+            out = self._log_line(process.stdout)
 
     def _do_one_rebaseline(self):
         try:
             old_branch_name = self._tool.scm().current_branch()
             self._log_to_server(is_new_entry=True)
             self._run_logged_command(['git', 'pull'])
             rebaseline_command = [self._tool.filesystem.join(self._tool.scm().checkout_root, 'Tools', 'Scripts', 'webkit-patch'), 'auto-rebaseline']
             if self._verbose:
                 rebaseline_command.append('--verbose')
             self._run_logged_command(rebaseline_command)
         except:
             traceback.print_exc(file=sys.stderr)
             # Sometimes git crashes and leaves us on a detached head.
             self._tool.scm().checkout_branch(old_branch_name)
 
     def execute(self, options, args, tool):
         self._verbose = options.verbose
         while True:
             self._do_one_rebaseline()
             time.sleep(self.SLEEP_TIME_IN_SECONDS)