File: serial_chooser_context.h

package info (click to toggle)
chromium 139.0.7258.127-1
  • links: PTS, VCS
  • area: main
  • in suites:
  • size: 6,122,068 kB
  • sloc: cpp: 35,100,771; ansic: 7,163,530; javascript: 4,103,002; python: 1,436,920; asm: 946,517; xml: 746,709; pascal: 187,653; perl: 88,691; sh: 88,436; objc: 79,953; sql: 51,488; cs: 44,583; fortran: 24,137; makefile: 22,147; tcl: 15,277; php: 13,980; yacc: 8,984; ruby: 7,485; awk: 3,720; lisp: 3,096; lex: 1,327; ada: 727; jsp: 228; sed: 36
file content (159 lines) | stat: -rw-r--r-- 6,118 bytes parent folder | download | duplicates (5)
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
// Copyright 2019 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_SERIAL_SERIAL_CHOOSER_CONTEXT_H_
#define CHROME_BROWSER_SERIAL_SERIAL_CHOOSER_CONTEXT_H_

#include <map>
#include <memory>
#include <set>
#include <string>
#include <utility>
#include <vector>

#include "base/memory/raw_ptr.h"
#include "base/memory/weak_ptr.h"
#include "base/observer_list.h"
#include "base/scoped_observation.h"
#include "base/scoped_observation_traits.h"
#include "base/unguessable_token.h"
#include "components/permissions/object_permission_context_base.h"
#include "content/public/browser/serial_delegate.h"
#include "mojo/public/cpp/bindings/pending_remote.h"
#include "mojo/public/cpp/bindings/receiver.h"
#include "mojo/public/cpp/bindings/remote.h"
#include "services/device/public/mojom/serial.mojom-forward.h"
#include "third_party/blink/public/mojom/serial/serial.mojom.h"
#include "url/origin.h"

class Profile;

namespace base {
class Value;
}

class SerialChooserContext
    : public permissions::ObjectPermissionContextBase,
      public permissions::ObjectPermissionContextBase::PermissionObserver,
      public device::mojom::SerialPortManagerClient {
 public:
  using PortObserver = content::SerialDelegate::Observer;

  explicit SerialChooserContext(Profile* profile);

  SerialChooserContext(const SerialChooserContext&) = delete;
  SerialChooserContext& operator=(const SerialChooserContext&) = delete;

  ~SerialChooserContext() override;

  static base::Value::Dict PortInfoToValue(
      const device::mojom::SerialPortInfo& port);

  // ObjectPermissionContextBase:
  std::string GetKeyForObject(const base::Value::Dict& object) override;
  bool IsValidObject(const base::Value::Dict& object) override;
  std::u16string GetObjectDisplayName(const base::Value::Dict& object) override;
  // ObjectPermissionContextBase::PermissionObserver:
  void OnPermissionRevoked(const url::Origin& origin) override;

  // In addition these methods from ObjectPermissionContextBase are overridden
  // in order to expose ephemeral devices through the public interface.
  std::vector<std::unique_ptr<Object>> GetGrantedObjects(
      const url::Origin& origin) override;
  std::vector<std::unique_ptr<Object>> GetAllGrantedObjects() override;
  void RevokeObjectPermission(const url::Origin& origin,
                              const base::Value::Dict& object) override;

  // Serial-specific interface for granting, checking, and revoking permissions.
  void GrantPortPermission(const url::Origin& origin,
                           const device::mojom::SerialPortInfo& port);
  bool HasPortPermission(const url::Origin& origin,
                         const device::mojom::SerialPortInfo& port);
  void RevokePortPermissionWebInitiated(const url::Origin& origin,
                                        const base::UnguessableToken& token);
  static bool CanStorePersistentEntry(
      const device::mojom::SerialPortInfo& port);

  // Only call this if you're sure |port_info_| has been initialized
  // before-hand. The returned raw pointer is owned by |port_info_| and will be
  // destroyed when the port is removed.
  const device::mojom::SerialPortInfo* GetPortInfo(
      const base::UnguessableToken& token);

  device::mojom::SerialPortManager* GetPortManager();

  void AddPortObserver(PortObserver* observer);
  void RemovePortObserver(PortObserver* observer);

  void SetPortManagerForTesting(
      mojo::PendingRemote<device::mojom::SerialPortManager> manager);
  void FlushPortManagerConnectionForTesting();
  base::WeakPtr<SerialChooserContext> AsWeakPtr();

  // SerialPortManagerClient implementation.
  void OnPortAdded(device::mojom::SerialPortInfoPtr port) override;
  void OnPortRemoved(device::mojom::SerialPortInfoPtr port) override;
  void OnPortConnectedStateChanged(
      device::mojom::SerialPortInfoPtr port) override;

  // KeyedService:
  void Shutdown() override;

  Profile* profile() { return profile_.get(); }

 private:
  void EnsurePortManagerConnection();
  void SetUpPortManagerConnection(
      mojo::PendingRemote<device::mojom::SerialPortManager> manager);
  void OnGetDevices(std::vector<device::mojom::SerialPortInfoPtr> ports);
  void OnPortManagerConnectionError();
  bool CanApplyPortSpecificPolicy();

  void RevokeObjectPermissionInternal(const url::Origin& origin,
                                      const base::Value::Dict& object,
                                      bool revoked_by_website);

  // This raw pointer is safe because instances of this class are created by
  // SerialChooserContextFactory as KeyedServices that will be destroyed when
  // the Profile object is destroyed.
  const raw_ptr<Profile> profile_;

  bool is_initialized_ = false;

  // Tracks the set of ports to which an origin has access to.
  std::map<url::Origin, std::set<base::UnguessableToken>> ephemeral_ports_;

  // Map from port token to port info.
  std::map<base::UnguessableToken, device::mojom::SerialPortInfoPtr> port_info_;

  mojo::Remote<device::mojom::SerialPortManager> port_manager_;
  mojo::Receiver<device::mojom::SerialPortManagerClient> client_receiver_{this};
  base::ObserverList<PortObserver> port_observer_list_;

  base::ScopedObservation<
      permissions::ObjectPermissionContextBase,
      permissions::ObjectPermissionContextBase::PermissionObserver>
      permission_observation_{this};

  base::WeakPtrFactory<SerialChooserContext> weak_factory_{this};
};

namespace base {

template <>
struct ScopedObservationTraits<SerialChooserContext,
                               SerialChooserContext::PortObserver> {
  static void AddObserver(SerialChooserContext* source,
                          SerialChooserContext::PortObserver* observer) {
    source->AddPortObserver(observer);
  }
  static void RemoveObserver(SerialChooserContext* source,
                             SerialChooserContext::PortObserver* observer) {
    source->RemovePortObserver(observer);
  }
};

}  // namespace base

#endif  // CHROME_BROWSER_SERIAL_SERIAL_CHOOSER_CONTEXT_H_