Move Mac LaunchOnStartup enable/disable to File thread

chrome/browser/background_mode_manager.h

 // 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.
 
 #ifndef CHROME_BROWSER_BACKGROUND_MODE_MANAGER_H_
 #define CHROME_BROWSER_BACKGROUND_MODE_MANAGER_H_
 #pragma once
 
 #include "app/menus/simple_menu_model.h"
 #include "base/gtest_prod_util.h"
+#include "base/task.h"
 #include "chrome/browser/background_application_list_model.h"
 #include "chrome/browser/prefs/pref_change_registrar.h"
 #include "chrome/browser/status_icons/status_icon.h"
 #include "chrome/common/notification_observer.h"
 #include "chrome/common/notification_registrar.h"
 
 class Browser;
 class CommandLine;
 class Extension;
 class PrefService;
@@ skipping 21 matching lines @@
       public BackgroundApplicationListModel::Observer {
  public:
   BackgroundModeManager(Profile* profile, CommandLine* command_line);
   virtual ~BackgroundModeManager();
 
   static void RegisterUserPrefs(PrefService* prefs);
 
   static bool IsBackgroundModeEnabled(const CommandLine* command_line);
 
  private:
+  class DisableLaunchOnStartupTask : public Task {
+   public:
+    explicit DisableLaunchOnStartupTask(BackgroundModeManager* manager)
+      : manager_(manager) {

[Andrew T Wilson (Slow), 2010/12/03 02:06:59]

I'm really nervous about passing the BackgroundModeManager in to the task - it's
not a thread-safe object, and I suspect the APIs we're calling (which access
prefs) will fail if called from the file thread.

On a related note, I don't think that the Task object should be the interface
point for cross-platform behavior. For one reason, you end up having to pollute
the object with things like manager_ which isn't needed across all platforms
(for that matter, the Tasks themselves aren't really needed on chromeos since we
don't do anything).

I think a cleaner way to go is to define to instance methods:
DisableLaunchOnStartup() and EnableLaunchOnStartup(), and you can implement
those on each platform. This will let you run platform specific code (like
IsLaunchOnStartupResetAllowed()) on the correct thread, and also let you omit
the Tasks entirely if the platform doesn't need them for some reason (like
chromeos). The downside is the PostTask call needs to be duplicated on each
platform, but I don't think that's a big deal.

[The wrong rickcam account, 2010/12/04 02:08:04]

Done.  I've pushed the EnableLaunchOnStartup definition down into the
platform-specific files, and then reorganized and cleaned-up those files.  A
positive side-effect is that I was also able to move the Task class definitions
out of the header file.

+    }
+    virtual void Run();
+   private:
+    BackgroundModeManager* manager_;
+  };
+
+  class EnableLaunchOnStartupTask : public Task {
+   public:
+    explicit EnableLaunchOnStartupTask(BackgroundModeManager* manager)
+      : manager_(manager) {
+    }
+    virtual void Run();
+   private:
+    BackgroundModeManager* manager_;
+  };
+
   friend class TestBackgroundModeManager;
   friend class BackgroundModeManagerTest;
   FRIEND_TEST_ALL_PREFIXES(BackgroundModeManagerTest,
                            BackgroundAppLoadUnload);
   FRIEND_TEST_ALL_PREFIXES(BackgroundModeManagerTest,
                            BackgroundAppInstallUninstall);
   FRIEND_TEST_ALL_PREFIXES(BackgroundModeManagerTest,
                            BackgroundPrefDisabled);
   FRIEND_TEST_ALL_PREFIXES(BackgroundModeManagerTest,
                            BackgroundPrefDynamicDisable);
@@ skipping 50 matching lines @@
   // Invoked to take Chrome out of KeepAlive mode - chrome stops running in
   // the background and removes its status bar icon.
   void EndBackgroundMode();
 
   // If --no-startup-window is passed, BackgroundModeManager will manually keep
   // chrome running while waiting for apps to load. This is called when we no
   // longer need to do this (either because the user has chosen to exit chrome
   // manually, or all apps have been loaded).
   void EndKeepAliveForStartup();
 
+  // Add a Preferences (or Options, or Settings) entry to the Status Icon's
+  // context menu.
+  void AddPreferencesItem(menus::SimpleMenuModel* menu);
+
   // Create a status tray icon to allow the user to shutdown Chrome when running
   // in background mode. Virtual to enable testing.
   virtual void CreateStatusTrayIcon();
 
   // Removes the status tray icon because we are exiting background mode.
   // Virtual to enable testing.
   virtual void RemoveStatusTrayIcon();
 
   // Updates the status icon's context menu entry corresponding to |extension|
   // to use the icon associated with |extension| in the
@@ skipping 43 matching lines @@
   // platform doesn't support status icons.
   StatusTray* status_tray_;
 
   // Reference to our status icon (if any) - owned by the StatusTray.
   StatusIcon* status_icon_;
 
   DISALLOW_COPY_AND_ASSIGN(BackgroundModeManager);
 };
 
 #endif  // CHROME_BROWSER_BACKGROUND_MODE_MANAGER_H_