[M73 Dev][EFL] Disable VizDisplayCompositor for EFL port
[platform/framework/web/chromium-efl.git] / components / cast_channel / cast_socket_service.cc
1 // Copyright 2017 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 #include "components/cast_channel/cast_socket_service.h"
6
7 #include "base/memory/ptr_util.h"
8 #include "base/task/post_task.h"
9 #include "components/cast_channel/cast_socket.h"
10 #include "components/cast_channel/logger.h"
11 #include "content/public/browser/browser_task_traits.h"
12 #include "content/public/browser/browser_thread.h"
13
14 using content::BrowserThread;
15
16 namespace cast_channel {
17
18 int CastSocketService::last_channel_id_ = 0;
19
20 CastSocketService::CastSocketService()
21     : logger_(new Logger()),
22       // IO thread's task runner is used because of:
23       // (1) ChromeURLRequestContextGetter::GetURLRequestContext, which is
24       // called by CastMediaSinkServiceImpl, must run on IO thread. (2) Parts of
25       // CastChannel extension API functions run on IO thread.
26       task_runner_(base::CreateSingleThreadTaskRunnerWithTraits(
27           {content::BrowserThread::IO})) {}
28
29 // This is a leaky singleton and the dtor won't be called.
30 CastSocketService::~CastSocketService() = default;
31
32 // static
33 CastSocketService* CastSocketService::GetInstance() {
34   static CastSocketService* instance = new CastSocketService();
35   return instance;
36 }
37
38 scoped_refptr<Logger> CastSocketService::GetLogger() {
39   return logger_;
40 }
41
42 CastSocket* CastSocketService::AddSocket(std::unique_ptr<CastSocket> socket) {
43   DCHECK(task_runner_->BelongsToCurrentThread());
44   DCHECK(socket);
45   int id = ++last_channel_id_;
46   socket->set_id(id);
47
48   auto* socket_ptr = socket.get();
49   sockets_.insert(std::make_pair(id, std::move(socket)));
50   return socket_ptr;
51 }
52
53 std::unique_ptr<CastSocket> CastSocketService::RemoveSocket(int channel_id) {
54   DCHECK(task_runner_->BelongsToCurrentThread());
55   DCHECK(channel_id > 0);
56   auto socket_it = sockets_.find(channel_id);
57
58   std::unique_ptr<CastSocket> socket;
59   if (socket_it != sockets_.end()) {
60     socket = std::move(socket_it->second);
61     sockets_.erase(socket_it);
62   }
63   return socket;
64 }
65
66 CastSocket* CastSocketService::GetSocket(int channel_id) const {
67   DCHECK(task_runner_->BelongsToCurrentThread());
68   DCHECK(channel_id > 0);
69   const auto& socket_it = sockets_.find(channel_id);
70   return socket_it == sockets_.end() ? nullptr : socket_it->second.get();
71 }
72
73 CastSocket* CastSocketService::GetSocket(
74     const net::IPEndPoint& ip_endpoint) const {
75   DCHECK(task_runner_->BelongsToCurrentThread());
76   auto it = std::find_if(
77       sockets_.begin(), sockets_.end(),
78       [&ip_endpoint](
79           const std::pair<const int, std::unique_ptr<CastSocket>>& pair) {
80         return pair.second->ip_endpoint() == ip_endpoint;
81       });
82   return it == sockets_.end() ? nullptr : it->second.get();
83 }
84
85 void CastSocketService::OpenSocket(NetworkContextGetter network_context_getter,
86                                    const CastSocketOpenParams& open_params,
87                                    CastSocket::OnOpenCallback open_cb) {
88   DCHECK(task_runner_->BelongsToCurrentThread());
89
90   const net::IPEndPoint& ip_endpoint = open_params.ip_endpoint;
91   auto* socket = GetSocket(ip_endpoint);
92   if (!socket) {
93     // If cast socket does not exist.
94     if (socket_for_test_) {
95       socket = AddSocket(std::move(socket_for_test_));
96     } else {
97       socket = new CastSocketImpl(network_context_getter, open_params, logger_);
98       AddSocket(base::WrapUnique(socket));
99     }
100   }
101
102   for (auto& observer : observers_)
103     socket->AddObserver(&observer);
104
105   socket->Connect(std::move(open_cb));
106 }
107
108 void CastSocketService::AddObserver(CastSocket::Observer* observer) {
109   DCHECK(task_runner_->BelongsToCurrentThread());
110   DCHECK(observer);
111   if (observers_.HasObserver(observer))
112     return;
113
114   observers_.AddObserver(observer);
115   for (auto& socket_it : sockets_)
116     socket_it.second->AddObserver(observer);
117 }
118
119 void CastSocketService::RemoveObserver(CastSocket::Observer* observer) {
120   DCHECK(task_runner_->BelongsToCurrentThread());
121   DCHECK(observer);
122
123   for (auto& socket_it : sockets_)
124     socket_it.second->RemoveObserver(observer);
125   observers_.RemoveObserver(observer);
126 }
127
128 void CastSocketService::SetSocketForTest(
129     std::unique_ptr<cast_channel::CastSocket> socket_for_test) {
130   socket_for_test_ = std::move(socket_for_test);
131 }
132
133 }  // namespace cast_channel