blob: 9922c11922b6dba26919f230aaa65603544b310e (
plain)
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
|
// Copyright 2016 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 COMPONENTS_ARC_INTENT_HELPER_ARC_INTENT_HELPER_BRIDGE_H_
#define COMPONENTS_ARC_INTENT_HELPER_ARC_INTENT_HELPER_BRIDGE_H_
#include <map>
#include <memory>
#include <set>
#include <string>
#include <vector>
#include "base/macros.h"
#include "base/observer_list.h"
#include "base/threading/thread_checker.h"
#include "components/arc/common/intent_helper.mojom.h"
#include "components/arc/intent_helper/activity_icon_loader.h"
#include "components/arc/intent_helper/arc_intent_helper_observer.h"
#include "components/keyed_service/core/keyed_service.h"
#include "url/gurl.h"
class KeyedServiceBaseFactory;
namespace content {
class BrowserContext;
} // namespace content
namespace arc {
class ArcBridgeService;
class IntentFilter;
// Receives intents from ARC.
class ArcIntentHelperBridge
: public KeyedService,
public mojom::IntentHelperHost {
public:
// Returns singleton instance for the given BrowserContext,
// or nullptr if the browser |context| is not allowed to use ARC.
static ArcIntentHelperBridge* GetForBrowserContext(
content::BrowserContext* context);
// Returns factory for the ArcIntentHelperBridge.
static KeyedServiceBaseFactory* GetFactory();
// Appends '.' + |to_append| to the intent helper package name.
static std::string AppendStringToIntentHelperPackageName(
const std::string& to_append);
ArcIntentHelperBridge(content::BrowserContext* context,
ArcBridgeService* bridge_service);
~ArcIntentHelperBridge() override;
void AddObserver(ArcIntentHelperObserver* observer);
void RemoveObserver(ArcIntentHelperObserver* observer);
bool HasObserver(ArcIntentHelperObserver* observer) const;
// mojom::IntentHelperHost
void OnIconInvalidated(const std::string& package_name) override;
void OnIntentFiltersUpdated(
std::vector<IntentFilter> intent_filters) override;
void OnOpenDownloads() override;
void OnOpenUrl(const std::string& url) override;
void OnOpenChromePage(mojom::ChromePage page) override;
void OpenWallpaperPicker() override;
void SetWallpaperDeprecated(const std::vector<uint8_t>& jpeg_data) override;
void OpenVolumeControl() override;
class OpenUrlDelegate {
public:
virtual ~OpenUrlDelegate() = default;
// Opens the given URL in the Chrome browser.
virtual void OpenUrl(const GURL& url) = 0;
};
// Retrieves icons for the |activities| and calls |callback|.
// See ActivityIconLoader::GetActivityIcons() for more details.
using ActivityName = internal::ActivityIconLoader::ActivityName;
// A part of OnIconsReadyCallback signature.
using ActivityToIconsMap = internal::ActivityIconLoader::ActivityToIconsMap;
using OnIconsReadyCallback =
internal::ActivityIconLoader::OnIconsReadyCallback;
using GetResult = internal::ActivityIconLoader::GetResult;
GetResult GetActivityIcons(const std::vector<ActivityName>& activities,
OnIconsReadyCallback callback);
// Returns true when |url| can only be handled by Chrome. Otherwise, which is
// when there might be one or more ARC apps that can handle |url|, returns
// false. This function synchronously checks the |url| without making any IPC
// to ARC side. Note that this function only supports http and https. If url's
// scheme is neither http nor https, the function immediately returns true
// without checking the filters.
bool ShouldChromeHandleUrl(const GURL& url);
// Returns false if |package_name| is for the intent_helper apk.
static bool IsIntentHelperPackage(const std::string& package_name);
// Filters out handlers that belong to the intent_helper apk and returns
// a new array.
static std::vector<mojom::IntentHandlerInfoPtr> FilterOutIntentHelper(
std::vector<mojom::IntentHandlerInfoPtr> handlers);
void SetOpenUrlDelegateForTesting(
std::unique_ptr<OpenUrlDelegate> open_url_delegate);
static const char kArcIntentHelperPackageName[];
private:
THREAD_CHECKER(thread_checker_);
content::BrowserContext* const context_;
ArcBridgeService* const arc_bridge_service_; // Owned by ArcServiceManager.
std::unique_ptr<OpenUrlDelegate> open_url_delegate_;
internal::ActivityIconLoader icon_loader_;
// List of intent filters from Android. Used to determine if Chrome should
// handle a URL without handing off to Android.
std::vector<IntentFilter> intent_filters_;
base::ObserverList<ArcIntentHelperObserver> observer_list_;
// about: and chrome://settings pages assistant requires to launch via
// OnOpenChromePage.
const std::map<mojom::ChromePage, std::string> allowed_chrome_pages_map_;
// Schemes that ARC is known to send via OnOpenUrl.
const std::set<std::string> allowed_arc_schemes_;
DISALLOW_COPY_AND_ASSIGN(ArcIntentHelperBridge);
};
} // namespace arc
#endif // COMPONENTS_ARC_INTENT_HELPER_ARC_INTENT_HELPER_BRIDGE_H_
|
