1// Copyright (c) 2012 The Chromium Authors. All rights reserved.
2// Use of this source code is governed by a BSD-style license that can be
3// found in the LICENSE file.
4
5#ifndef CHROME_BROWSER_UI_WEBUI_OPTIONS_OPTIONS_UI_H_
6#define CHROME_BROWSER_UI_WEBUI_OPTIONS_OPTIONS_UI_H_
7
8#include <string>
9#include <vector>
10
11#include "base/callback_list.h"
12#include "base/compiler_specific.h"
13#include "base/memory/scoped_ptr.h"
14#include "content/public/browser/notification_registrar.h"
15#include "content/public/browser/web_contents_observer.h"
16#include "content/public/browser/web_ui_controller.h"
17#include "content/public/browser/web_ui_message_handler.h"
18#include "ui/base/layout.h"
19
20class AutocompleteResult;
21
22namespace base {
23class DictionaryValue;
24class ListValue;
25class RefCountedMemory;
26}
27
28#if defined(OS_CHROMEOS)
29namespace chromeos {
30namespace system {
31class PointerDeviceObserver;
32}  // namespace system
33}  // namespace chromeos
34#endif
35
36namespace options {
37
38// The base class handler of Javascript messages of options pages.
39class OptionsPageUIHandler : public content::WebUIMessageHandler {
40 public:
41  // Key for identifying the Settings App localized_strings in loadTimeData.
42  static const char kSettingsAppKey[];
43
44  OptionsPageUIHandler();
45  virtual ~OptionsPageUIHandler();
46
47  // Is this handler enabled?
48  virtual bool IsEnabled();
49
50  // Collects localized strings for options page.
51  virtual void GetLocalizedValues(base::DictionaryValue* localized_strings) = 0;
52
53  virtual void PageLoadStarted() {}
54
55  // Will be called only once in the life time of the handler. Generally used to
56  // add observers, initializes preferences, or start asynchronous calls from
57  // various services.
58  virtual void InitializeHandler() {}
59
60  // Initialize the page. Called once the DOM is available for manipulation.
61  // This will be called when a RenderView is re-used (when navigated to with
62  // back/forward or session restored in some cases) or when created.
63  virtual void InitializePage() {}
64
65  // Uninitializes the page.  Called just before the object is destructed.
66  virtual void Uninitialize() {}
67
68  // WebUIMessageHandler implementation.
69  virtual void RegisterMessages() OVERRIDE {}
70
71 protected:
72  struct OptionsStringResource {
73    // The name of the resource in templateData.
74    const char* name;
75    // The .grd ID for the resource (IDS_*).
76    int id;
77    // The .grd ID of the string to replace $1 in |id|'s string. If zero or
78    // omitted (default initialized), no substitution is attempted.
79    int substitution_id;
80  };
81
82  // A helper to simplify string registration in WebUI for strings which do not
83  // change at runtime and optionally contain a single substitution.
84  static void RegisterStrings(base::DictionaryValue* localized_strings,
85                              const OptionsStringResource* resources,
86                              size_t length);
87
88  // Registers string resources for a page's header and tab title.
89  static void RegisterTitle(base::DictionaryValue* localized_strings,
90                            const std::string& variable_name,
91                            int title_id);
92
93  content::NotificationRegistrar registrar_;
94
95 private:
96  DISALLOW_COPY_AND_ASSIGN(OptionsPageUIHandler);
97};
98
99// An interface for common operations that a host of OptionsPageUIHandlers
100// should provide.
101class OptionsPageUIHandlerHost {
102 public:
103  virtual void InitializeHandlers() = 0;
104  virtual void OnFinishedLoading() {}
105
106 protected:
107  virtual ~OptionsPageUIHandlerHost() {}
108};
109
110// The WebUI for chrome:settings-frame.
111class OptionsUI : public content::WebUIController,
112                  public content::WebContentsObserver,
113                  public OptionsPageUIHandlerHost {
114 public:
115  typedef base::CallbackList<void()> OnFinishedLoadingCallbackList;
116
117  explicit OptionsUI(content::WebUI* web_ui);
118  virtual ~OptionsUI();
119
120  // Registers a callback to be called once the settings frame has finished
121  // loading on the HTML/JS side.
122  scoped_ptr<OnFinishedLoadingCallbackList::Subscription>
123      RegisterOnFinishedLoadingCallback(const base::Closure& callback);
124
125  // Takes the suggestions from |result| and adds them to |suggestions| so that
126  // they can be passed to a JavaScript function.
127  static void ProcessAutocompleteSuggestions(
128      const AutocompleteResult& result,
129      base::ListValue* const suggestions);
130
131  static base::RefCountedMemory* GetFaviconResourceBytes(
132      ui::ScaleFactor scale_factor);
133
134  // Overridden from content::WebContentsObserver:
135  virtual void DidStartProvisionalLoadForFrame(
136      content::RenderFrameHost* render_frame_host,
137      const GURL& validated_url,
138      bool is_error_page,
139      bool is_iframe_srcdoc) OVERRIDE;
140
141  // Overridden from OptionsPageUIHandlerHost:
142  virtual void InitializeHandlers() OVERRIDE;
143  virtual void OnFinishedLoading() OVERRIDE;
144
145 private:
146  // Adds OptionsPageUiHandler to the handlers list if handler is enabled.
147  void AddOptionsPageUIHandler(base::DictionaryValue* localized_strings,
148                               OptionsPageUIHandler* handler);
149
150  bool initialized_handlers_;
151
152  std::vector<OptionsPageUIHandler*> handlers_;
153  OnFinishedLoadingCallbackList on_finished_loading_callbacks_;
154
155#if defined(OS_CHROMEOS)
156  scoped_ptr<chromeos::system::PointerDeviceObserver>
157      pointer_device_observer_;
158#endif
159
160  DISALLOW_COPY_AND_ASSIGN(OptionsUI);
161};
162
163}  // namespace options
164
165#endif  // CHROME_BROWSER_UI_WEBUI_OPTIONS_OPTIONS_UI_H_
166