Prototype version of the first-run dialog for Windows 8

chrome/browser/shell_integration.h

 // Copyright (c) 2012 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_SHELL_INTEGRATION_H_
 #define CHROME_BROWSER_SHELL_INTEGRATION_H_
 #pragma once
 
 #include <string>
 
@@ skipping 151 matching lines @@
     STATE_NOT_DEFAULT,
     STATE_IS_DEFAULT,
     STATE_UNKNOWN
   };
 
   class DefaultWebClientObserver {
    public:
     virtual ~DefaultWebClientObserver() {}
     // Updates the UI state to reflect the current default browser state.
     virtual void SetDefaultWebClientUIState(DefaultWebClientUIState state) = 0;
+    // Called to notify the UI of the immediate result of invoking
+    // SetAsDefault.
+    virtual void OnSetAsDefaultConcluded(bool succeeded) {}
     // Observer classes that return true to OwnedByWorker are automatically
-    // freed by the worker when they are no longer needed.
-    virtual bool IsOwnedByWorker() { return false; }
+    // freed by the worker when they are no longer needed. False by default.
+    virtual bool IsOwnedByWorker();
     // An observer can permit or decline set-as-default operation if it
-    // requires triggering user interaction.
-    virtual bool IsInteractiveSetDefaultPermitted() { return false; }
+    // requires triggering user interaction. By default not allowed.
+    virtual bool IsInteractiveSetDefaultPermitted();
   };
 
   //  Helper objects that handle checking if Chrome is the default browser
   //  or application for a url protocol on Windows and Linux, and also setting
   //  it as the default. These operations are performed asynchronously on the
   //  file thread since registry access (on Windows) or the preference database
   //  (on Linux) are involved and this can be slow.
   class DefaultWebClientWorker
       : public base::RefCountedThreadSafe<DefaultWebClientWorker> {
    public:
@@ skipping 14 matching lines @@
 
    protected:
     friend class base::RefCountedThreadSafe<DefaultWebClientWorker>;
 
     virtual ~DefaultWebClientWorker() {}
 
    private:
     // Function that performs the check.
     virtual DefaultWebClientState CheckIsDefault() = 0;
 
-    // Function that sets Chrome as the default web client.
-    virtual void SetAsDefault(bool interactive_permitted) = 0;
+    // Function that sets Chrome as the default web client. Returns false if
+    // the operation fails or has been cancelled by the user.
+    virtual bool SetAsDefault(bool interactive_permitted) = 0;
 
     // Function that handles performing the check on the file thread. This
     // function is posted as a task onto the file thread, where it performs
     // the check. When the check has finished the CompleteCheckIsDefault
     // function is posted to the UI thread, where the result is sent back to
     // the observer.
     void ExecuteCheckIsDefault();
 
     // Function that handles setting Chrome as the default web client on the
     // file thread. This function is posted as a task onto the file thread.
     // Once it is finished the CompleteSetAsDefault function is posted to the
     // UI thread which will check the status of Chrome as the default, and
     // send this to the observer.
-    void ExecuteSetAsDefault();
+    // |interactive_permitted| indicates if the routine is allowed to carry on
+    // in context where user interaction is required (CanSetAsDefault*
+    // returns SET_DEFAULT_INTERACTIVE).
+    void ExecuteSetAsDefault(bool interactive_permitted);
 
     // Communicate results to the observer. This function is posted as a task
     // onto the UI thread by the ExecuteCheckIsDefault function running in the
     // file thread.
     void CompleteCheckIsDefault(DefaultWebClientState state);
 
     // When the action to set Chrome as the default has completed this function
     // is run. It is posted as a task back onto the UI thread by the
     // ExecuteSetAsDefault function running in the file thread. This function
     // will the start the check process, which, if an observer is present,
     // reports to it the new status.
-    void CompleteSetAsDefault();
+    // |succeeded| is true if the actual call to a set-default function (from
+    // ExecuteSetAsDefault) was successful.
+    void CompleteSetAsDefault(bool succeeded);
 
     // Updates the UI in our associated view with the current default web
     // client state.
     void UpdateUI(DefaultWebClientState state);
 
     DefaultWebClientObserver* observer_;
 
     DISALLOW_COPY_AND_ASSIGN(DefaultWebClientWorker);
   };
 
   // Worker for checking and setting the default browser.
   class DefaultBrowserWorker : public DefaultWebClientWorker {
    public:
     explicit DefaultBrowserWorker(DefaultWebClientObserver* observer);
 
    private:
     virtual ~DefaultBrowserWorker() {}
 
     // Check if Chrome is the default browser.
     virtual DefaultWebClientState CheckIsDefault() OVERRIDE;
 
     // Set Chrome as the default browser.
-    virtual void SetAsDefault(bool interactive_permitted) OVERRIDE;
+    virtual bool SetAsDefault(bool interactive_permitted) OVERRIDE;
 
     DISALLOW_COPY_AND_ASSIGN(DefaultBrowserWorker);
   };
 
   // Worker for checking and setting the default client application
   // for a given protocol. A different worker instance is needed for each
   // protocol you are interested in, so to check or set the default for
   // multiple protocols you should use multiple worker objects.
   class DefaultProtocolClientWorker : public DefaultWebClientWorker {
    public:
     DefaultProtocolClientWorker(DefaultWebClientObserver* observer,
                                 const std::string& protocol);
 
     const std::string& protocol() const { return protocol_; }
 
    protected:
     virtual ~DefaultProtocolClientWorker() {}
 
    private:
     // Check is Chrome is the default handler for this protocol.
     virtual DefaultWebClientState CheckIsDefault() OVERRIDE;
 
     // Set Chrome as the default handler for this protocol.
-    virtual void SetAsDefault(bool interactive_permitted) OVERRIDE;
+    virtual bool SetAsDefault(bool interactive_permitted) OVERRIDE;
 
     std::string protocol_;
 
     DISALLOW_COPY_AND_ASSIGN(DefaultProtocolClientWorker);
   };
 };
 
 #endif  // CHROME_BROWSER_SHELL_INTEGRATION_H_