Allow overriding of X error functions

chrome/browser/browser_process_impl.cc

 // Copyright (c) 2010 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.
 
 #include "chrome/browser/browser_process_impl.h"
 
 #include <map>
 
 #include "app/clipboard/clipboard.h"
 #include "app/l10n_util.h"
 #include "base/command_line.h"
 #include "base/file_util.h"
 #include "base/path_service.h"
+#include "base/task.h"
 #include "base/thread.h"
 #include "base/waitable_event.h"
 #include "chrome/browser/appcache/chrome_appcache_service.h"
 #include "chrome/browser/automation/automation_provider_list.h"
 #include "chrome/browser/browser_child_process_host.h"
 #include "chrome/browser/browser_list.h"
 #include "chrome/browser/browser_main.h"
 #include "chrome/browser/browser_process_sub_thread.h"
 #include "chrome/browser/browser_trial.h"
 #include "chrome/browser/chrome_thread.h"
@@ skipping 43 matching lines @@
 #include "chrome/common/plugin_messages.h"
 #include "chrome/common/render_messages.h"
 #endif
 
 #if (defined(OS_WIN) || defined(OS_LINUX)) && !defined(OS_CHROMEOS)
 // How often to check if the persistent instance of Chrome needs to restart
 // to install an update.
 static const int kUpdateCheckIntervalHours = 6;
 #endif
 
+#if defined(USE_X11)
+// How long to wait for the File thread to complete during EndSession, on
+// Linux. We have a timeout here because we're unable to run the UI messageloop
+// and there's some deadlock risk. Our only option is to exit anyway.
+static const int kEndSessionTimeoutSeconds = 10;
+#endif
+
 BrowserProcessImpl::BrowserProcessImpl(const CommandLine& command_line)
     : created_resource_dispatcher_host_(false),
       created_metrics_service_(false),
       created_io_thread_(false),
       created_file_thread_(false),
       created_db_thread_(false),
       created_process_launcher_thread_(false),
       created_cache_thread_(false),
       created_profile_manager_(false),
       created_local_state_(false),
@@ skipping 121 matching lines @@
 
   // At this point, no render process exist and the file, io, db, and
   // webkit threads in this process have all terminated, so it's safe
   // to access local state data such as cookies, database, or local storage.
   if (clear_local_state_on_exit)
     ClearLocalState(profile_path);
 
   g_browser_process = NULL;
 }
 
+#if defined(OS_WIN)
 // Send a QuitTask to the given MessageLoop.
 static void PostQuit(MessageLoop* message_loop) {
   message_loop->PostTask(FROM_HERE, new MessageLoop::QuitTask());
 }
+#elif defined(USE_X11)
+static void Signal(base::WaitableEvent* event) {
+  event->Signal();
+}
+#endif
 
 unsigned int BrowserProcessImpl::AddRefModule() {
   DCHECK(CalledOnValidThread());
   did_start_ = true;
   module_ref_count_++;
   return module_ref_count_;
 }
 
 unsigned int BrowserProcessImpl::ReleaseModule() {
   DCHECK(CalledOnValidThread());
   DCHECK_NE(0u, module_ref_count_);
   module_ref_count_--;
   if (0 == module_ref_count_) {
     MessageLoop::current()->PostTask(
         FROM_HERE, NewRunnableFunction(DidEndMainMessageLoop));
     MessageLoop::current()->Quit();
   }
   return module_ref_count_;
 }
 
 void BrowserProcessImpl::EndSession() {
-#if defined(OS_WIN)
+#if defined(OS_WIN) || defined(USE_X11)
   // Notify we are going away.
-  ::SetEvent(shutdown_event_->handle());
+  shutdown_event_->Signal();
 #endif
 
   // Mark all the profiles as clean.
   ProfileManager* pm = profile_manager();
   for (ProfileManager::const_iterator i = pm->begin(); i != pm->end(); ++i)
     (*i)->MarkAsCleanShutdown();
 
   // Tell the metrics service it was cleanly shutdown.
   MetricsService* metrics = g_browser_process->metrics_service();
   if (metrics && local_state()) {
     metrics->RecordCleanShutdown();
 
     metrics->RecordStartOfSessionEnd();
 
     // MetricsService lazily writes to prefs, force it to write now.
     local_state()->SavePersistentPrefs();
   }
 
   // We must write that the profile and metrics service shutdown cleanly,
   // otherwise on startup we'll think we crashed. So we block until done and
   // then proceed with normal shutdown.
-  g_browser_process->file_thread()->message_loop()->PostTask(FROM_HERE,
+#if defined(USE_X11)
+  //  Can't run a local loop on linux. Instead create a waitable event.
+  base::WaitableEvent done_writing(false, false);
+  ChromeThread::PostTask(ChromeThread::FILE, FROM_HERE,
+      NewRunnableFunction(Signal, &done_writing));
+  done_writing.TimedWait(
+      base::TimeDelta::FromSeconds(kEndSessionTimeoutSeconds));
+#elif defined(OS_WIN)
+  ChromeThread::PostTask(ChromeThread::FILE, FROM_HERE,
       NewRunnableFunction(PostQuit, MessageLoop::current()));
   MessageLoop::current()->Run();
+#else
+  NOTIMPLEMENTED();
+#endif
 }
 
 ResourceDispatcherHost* BrowserProcessImpl::resource_dispatcher_host() {
   DCHECK(CalledOnValidThread());
   if (!created_resource_dispatcher_host_)
     CreateResourceDispatcherHost();
   return resource_dispatcher_host_.get();
 }
 
 MetricsService* BrowserProcessImpl::metrics_service() {
@@ skipping 503 matching lines @@
 }
 
 void BrowserProcessImpl::OnAutoupdateTimer() {
   if (CanAutorestartForUpdate()) {
     DLOG(WARNING) << "Detected update.  Restarting browser.";
     RestartPersistentInstance();
   }
 }
 
 #endif  // (defined(OS_WIN) || defined(OS_LINUX)) && !defined(OS_CHROMEOS)