1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176
|
// Copyright 2012 The Chromium Authors
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#ifndef CHROME_BROWSER_EXTENSIONS_WINDOW_CONTROLLER_H_
#define CHROME_BROWSER_EXTENSIONS_WINDOW_CONTROLLER_H_
#include <stdint.h>
#include <memory>
#include <string>
#include <vector>
#include "base/memory/raw_ptr.h"
#include "base/values.h"
#include "chrome/common/extensions/api/tabs.h"
#include "chrome/common/extensions/api/windows.h"
#include "extensions/common/mojom/context_type.mojom-forward.h"
class Browser; // TODO(stevenjb) eliminate this dependency.
class GURL;
class Profile;
namespace content {
class WebContents;
}
namespace ui {
class BaseWindow;
}
namespace extensions {
class Extension;
// This API provides a way for the extension system to talk "up" to the
// enclosing window (the `Browser` object on desktop builds) without depending
// on the implementation details of the exact object.
//
// Subclasses must add/remove themselves from the WindowControllerList upon
// construction/destruction.
class WindowController {
public:
enum PopulateTabBehavior {
kPopulateTabs,
kDontPopulateTabs,
};
enum Reason {
REASON_NONE,
REASON_NOT_EDITABLE,
};
// A bitmask used as filter on window types.
using TypeFilter = uint32_t;
// Represents the lack of any window filter, implying
// IsVisibleToExtension will be used as non-filtered behavior.
static const TypeFilter kNoWindowFilter = 0;
// Returns a filter allowing all window types to be manipulated
// through the chrome.windows APIs.
static TypeFilter GetAllWindowFilter();
// Builds a filter out of a vector of window types.
static TypeFilter GetFilterFromWindowTypes(
const std::vector<api::windows::WindowType>& types);
static TypeFilter GetFilterFromWindowTypesValues(
const base::Value::List* types);
WindowController(ui::BaseWindow* window, Profile* profile);
WindowController(const WindowController&) = delete;
WindowController& operator=(const WindowController&) = delete;
virtual ~WindowController();
ui::BaseWindow* window() const { return window_; }
Profile* profile() const { return profile_; }
// Return an id uniquely identifying the window.
virtual int GetWindowId() const = 0;
// Return the type name for the window.
// TODO(devlin): Remove this in favor of the method on ExtensionTabUtil.
virtual std::string GetWindowTypeText() const = 0;
// Sets the window's fullscreen state. `extension_url` provides the url
// associated with the extension (used by FullscreenController).
virtual void SetFullscreenMode(bool is_fullscreen,
const GURL& extension_url) const = 0;
// Returns false if the window is in a state where closing the window is not
// permitted and sets `reason` if not NULL.
virtual bool CanClose(Reason* reason) const = 0;
// Returns a Browser if available. Defaults to returning NULL.
// TODO(stevenjb): Temporary workaround. Eliminate this.
virtual Browser* GetBrowser() const;
// Returns true if the window is in the process of being torn down. See
// Browser::is_delete_scheduled().
virtual bool IsDeleteScheduled() const = 0;
// Returns the WebContents associated with the active tab, if any. Returns
// null if there is no active tab.
virtual content::WebContents* GetActiveTab() const = 0;
// Returns true if this window has a tab strip that's currently editable or
// if there's no visible tab strip.
//
// During some animations and drags the tab strip won't be editable and
// extensions should not update it. Many callers should use
// ExtensionTabUtil::IsTabStripEditable() which will check *all* tab strips
// because some move operations span tab strips. This checking of all windows
// is why windows that don't have visible tab strips should still return true
// here: otherwise they will prevent some operations from happening that use
// the ExtensionTabUtil.
virtual bool HasEditableTabStrip() const = 0;
// Returns the number of tabs in this window.
virtual int GetTabCount() const = 0;
// Returns the web contents at the given tab index, or null if it's off the
// end of the tab strip.
virtual content::WebContents* GetWebContentsAt(int i) const = 0;
// Returns true if the window is visible to the tabs API, when used by the
// given `extension`.
// `allow_dev_tools_windows` indicates whether dev tools windows should be
// treated as visible.
// TODO(devlin): Remove include_dev_tools_windows.
virtual bool IsVisibleToTabsAPIForExtension(
const Extension* extension,
bool include_dev_tools_windows) const = 0;
// Returns true if the window type of the controller matches the `filter`.
bool MatchesFilter(TypeFilter filter) const;
// Notifies that a window's bounds are changed.
void NotifyWindowBoundsChanged();
// Creates a base::Value::Dict representing the window for the browser and
// scrubs any privacy-sensitive data that `extension` does not have access to.
// `populate_tab_behavior` determines whether tabs will be populated in the
// result. `context` is used to determine the ScrubTabBehavior for the
// populated tabs data.
// TODO(devlin): Convert this to a api::Windows::Window object.
virtual base::Value::Dict CreateWindowValueForExtension(
const Extension* extension,
PopulateTabBehavior populate_tab_behavior,
mojom::ContextType context) const = 0;
// Returns the JSON tab information for all tabs in this window. See the
// chrome.tabs.getAllInWindow() extensions API.
virtual base::Value::List CreateTabList(const Extension* extension,
mojom::ContextType context) const = 0;
// Open the extension's options page as instructed. Returns true if an options
// page was successfully opened (though it may not necessarily *load*, e.g. if
// the URL does not exist).
virtual bool OpenOptionsPage(const Extension* extension,
const GURL& url,
bool open_in_tab) = 0;
// Returns true if the Browser can report tabs to extensions. Example of
// Browsers which don't support tabs include apps and devtools.
virtual bool SupportsTabs() = 0;
private:
raw_ptr<ui::BaseWindow, DanglingUntriaged> window_;
raw_ptr<Profile, DanglingUntriaged> profile_;
};
} // namespace extensions
#endif // CHROME_BROWSER_EXTENSIONS_WINDOW_CONTROLLER_H_
|