OLD | NEW |
1 // Copyright 2017 The Chromium Authors. All rights reserved. | 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 | 2 // Use of this source code is governed by a BSD-style license that can be |
3 // found in the LICENSE file. | 3 // found in the LICENSE file. |
4 | 4 |
5 #include "chrome/browser/media/router/discovery/dial/dial_media_sink_service.h" | 5 #include "chrome/browser/media/router/discovery/dial/dial_media_sink_service.h" |
6 | 6 |
7 #include "chrome/browser/media/router/discovery/dial/dial_device_data.h" | 7 #include "chrome/browser/media/router/discovery/dial/dial_device_data.h" |
8 #include "chrome/browser/profiles/profile.h" | 8 #include "chrome/browser/profiles/profile.h" |
9 #include "content/public/browser/browser_thread.h" | 9 #include "content/public/browser/browser_thread.h" |
10 #include "net/url_request/url_request_context_getter.h" | 10 #include "net/url_request/url_request_context_getter.h" |
11 | 11 |
12 using content::BrowserThread; | 12 using content::BrowserThread; |
13 | 13 |
14 namespace { | 14 namespace { |
15 // Time interval when media sink service sends sinks to MRP. | 15 // Time interval when media sink service sends sinks to MRP. |
16 const int kFetchCompleteTimeoutSecs = 3; | 16 const int kFetchCompleteTimeoutSecs = 3; |
17 } | 17 } |
18 | 18 |
19 namespace media_router { | 19 namespace media_router { |
20 | 20 |
21 DialMediaSinkService::DialMediaSinkService( | 21 DialMediaSinkService::DialMediaSinkService( |
22 const OnSinksDiscoveredCallback& callback, | 22 const OnSinksDiscoveredCallback& callback, |
23 net::URLRequestContextGetter* request_context) | 23 net::URLRequestContextGetter* request_context) |
24 : MediaSinkService(callback), request_context_(request_context) { | 24 : MediaSinkService(callback), request_context_(request_context) { |
25 DCHECK_CURRENTLY_ON(BrowserThread::IO); | 25 DCHECK_CURRENTLY_ON(BrowserThread::IO); |
26 DCHECK(request_context_); | 26 DCHECK(request_context_); |
27 } | 27 } |
28 | 28 |
29 DialMediaSinkService::~DialMediaSinkService() {} | 29 DialMediaSinkService::~DialMediaSinkService() { |
| 30 DCHECK_CURRENTLY_ON(BrowserThread::IO); |
| 31 Stop(); |
| 32 } |
30 | 33 |
31 void DialMediaSinkService::Start() { | 34 void DialMediaSinkService::Start() { |
32 DCHECK_CURRENTLY_ON(BrowserThread::IO); | 35 DCHECK_CURRENTLY_ON(BrowserThread::IO); |
33 dial_registry()->RegisterObserver(this); | 36 if (dial_registry_) |
34 dial_registry()->StartPeriodicDiscovery(); | 37 return; |
| 38 |
| 39 dial_registry_ = DialRegistry::GetInstance(); |
| 40 dial_registry_->RegisterObserver(this); |
| 41 dial_registry_->OnListenerAdded(); |
35 } | 42 } |
36 | 43 |
37 void DialMediaSinkService::Stop() { | 44 void DialMediaSinkService::Stop() { |
38 DCHECK_CURRENTLY_ON(BrowserThread::IO); | 45 DCHECK_CURRENTLY_ON(BrowserThread::IO); |
39 dial_registry()->UnregisterObserver(this); | 46 if (!dial_registry_) |
40 } | 47 return; |
41 | 48 |
42 DialRegistry* DialMediaSinkService::dial_registry() { | 49 dial_registry_->OnListenerRemoved(); |
43 DCHECK_CURRENTLY_ON(BrowserThread::IO); | 50 dial_registry_->UnregisterObserver(this); |
44 return DialRegistry::GetInstance(); | 51 dial_registry_ = nullptr; |
45 } | 52 } |
46 | 53 |
47 DeviceDescriptionService* DialMediaSinkService::GetDescriptionService() { | 54 DeviceDescriptionService* DialMediaSinkService::GetDescriptionService() { |
48 DCHECK_CURRENTLY_ON(BrowserThread::IO); | 55 DCHECK_CURRENTLY_ON(BrowserThread::IO); |
49 if (!description_service_.get()) { | 56 if (!description_service_.get()) { |
50 description_service_.reset(new DeviceDescriptionService( | 57 description_service_.reset(new DeviceDescriptionService( |
51 base::Bind(&DialMediaSinkService::OnDeviceDescriptionAvailable, | 58 base::Bind(&DialMediaSinkService::OnDeviceDescriptionAvailable, |
52 base::Unretained(this)), | 59 base::Unretained(this)), |
53 base::Bind(&DialMediaSinkService::OnDeviceDescriptionError, | 60 base::Bind(&DialMediaSinkService::OnDeviceDescriptionError, |
54 base::Unretained(this)))); | 61 base::Unretained(this)))); |
55 } | 62 } |
56 return description_service_.get(); | 63 return description_service_.get(); |
57 } | 64 } |
58 | 65 |
| 66 void DialMediaSinkService::SetDialRegistryForTest(DialRegistry* dial_registry) { |
| 67 DCHECK(!dial_registry_); |
| 68 dial_registry_ = dial_registry; |
| 69 |
| 70 DCHECK(dial_registry); |
| 71 dial_registry_->RegisterObserver(this); |
| 72 dial_registry_->OnListenerAdded(); |
| 73 } |
| 74 |
| 75 void DialMediaSinkService::SetDescriptionServiceForTest( |
| 76 std::unique_ptr<DeviceDescriptionService> description_service) { |
| 77 DCHECK(!description_service_); |
| 78 description_service_ = std::move(description_service); |
| 79 } |
| 80 |
| 81 void DialMediaSinkService::SetTimerForTest(std::unique_ptr<base::Timer> timer) { |
| 82 DCHECK(!finish_timer_); |
| 83 finish_timer_ = std::move(timer); |
| 84 } |
| 85 |
59 void DialMediaSinkService::OnDialDeviceEvent( | 86 void DialMediaSinkService::OnDialDeviceEvent( |
60 const DialRegistry::DeviceList& devices) { | 87 const DialRegistry::DeviceList& devices) { |
61 DCHECK_CURRENTLY_ON(BrowserThread::IO); | 88 DCHECK_CURRENTLY_ON(BrowserThread::IO); |
62 DVLOG(2) << "DialMediaSinkService::OnDialDeviceEvent found " << devices.size() | 89 DVLOG(2) << "DialMediaSinkService::OnDialDeviceEvent found " << devices.size() |
63 << " devices"; | 90 << " devices"; |
64 | 91 |
65 // Add a finish timer. | 92 StartTimer(); |
66 finish_timer_.reset(new base::OneShotTimer()); | |
67 base::TimeDelta finish_delay = | |
68 base::TimeDelta::FromSeconds(kFetchCompleteTimeoutSecs); | |
69 finish_timer_->Start(FROM_HERE, finish_delay, this, | |
70 &DialMediaSinkService::OnFetchCompleted); | |
71 | 93 |
72 current_sinks_.clear(); | 94 current_sinks_.clear(); |
73 current_devices_ = devices; | 95 current_devices_ = devices; |
74 | 96 |
75 GetDescriptionService()->GetDeviceDescriptions(devices, | 97 GetDescriptionService()->GetDeviceDescriptions(devices, |
76 request_context_.get()); | 98 request_context_.get()); |
77 } | 99 } |
78 | 100 |
79 void DialMediaSinkService::OnDialError(DialRegistry::DialErrorCode type) { | 101 void DialMediaSinkService::OnDialError(DialRegistry::DialErrorCode type) { |
80 DCHECK_CURRENTLY_ON(BrowserThread::IO); | 102 DCHECK_CURRENTLY_ON(BrowserThread::IO); |
(...skipping 19 matching lines...) Expand all Loading... |
100 extra_data.app_url = description_data.app_url; | 122 extra_data.app_url = description_data.app_url; |
101 extra_data.model_name = description_data.model_name; | 123 extra_data.model_name = description_data.model_name; |
102 std::string ip_address = device_data.device_description_url().host(); | 124 std::string ip_address = device_data.device_description_url().host(); |
103 if (!extra_data.ip_address.AssignFromIPLiteral(ip_address)) { | 125 if (!extra_data.ip_address.AssignFromIPLiteral(ip_address)) { |
104 DVLOG(1) << "Invalid ip_address: " << ip_address; | 126 DVLOG(1) << "Invalid ip_address: " << ip_address; |
105 return; | 127 return; |
106 } | 128 } |
107 | 129 |
108 current_sinks_.insert(MediaSinkInternal(sink, extra_data)); | 130 current_sinks_.insert(MediaSinkInternal(sink, extra_data)); |
109 | 131 |
110 if (finish_timer_) | |
111 return; | |
112 | |
113 // Start fetch timer again if device description comes back after | 132 // Start fetch timer again if device description comes back after |
114 // |finish_timer_| fires. | 133 // |finish_timer_| fires. |
115 base::TimeDelta finish_delay = | 134 if (!finish_timer_->IsRunning()) |
116 base::TimeDelta::FromSeconds(kFetchCompleteTimeoutSecs); | 135 StartTimer(); |
117 finish_timer_.reset(new base::OneShotTimer()); | |
118 finish_timer_->Start(FROM_HERE, finish_delay, this, | |
119 &DialMediaSinkService::OnFetchCompleted); | |
120 } | 136 } |
121 | 137 |
122 void DialMediaSinkService::OnDeviceDescriptionError( | 138 void DialMediaSinkService::OnDeviceDescriptionError( |
123 const DialDeviceData& device, | 139 const DialDeviceData& device, |
124 const std::string& error_message) { | 140 const std::string& error_message) { |
125 DCHECK_CURRENTLY_ON(BrowserThread::IO); | 141 DCHECK_CURRENTLY_ON(BrowserThread::IO); |
126 DVLOG(2) << "OnDescriptionFetchesError [message]: " << error_message; | 142 DVLOG(2) << "OnDescriptionFetchesError [message]: " << error_message; |
127 } | 143 } |
128 | 144 |
129 void DialMediaSinkService::OnFetchCompleted() { | 145 void DialMediaSinkService::OnFetchCompleted() { |
130 DCHECK_CURRENTLY_ON(BrowserThread::IO); | |
131 DCHECK(!sink_discovery_callback_.is_null()); | 146 DCHECK(!sink_discovery_callback_.is_null()); |
132 | 147 |
133 finish_timer_.reset(); | 148 if (current_sinks_ == mrp_sinks_) { |
134 | |
135 auto sinks = current_sinks_; | |
136 if (sinks == mrp_sinks_) { | |
137 DVLOG(2) << "No update to sink list."; | 149 DVLOG(2) << "No update to sink list."; |
138 return; | 150 return; |
139 } | 151 } |
140 | 152 |
141 DVLOG(2) << "Send sinks to media router, [size]: " << sinks.size(); | 153 DVLOG(2) << "Send sinks to media router, [size]: " << current_sinks_.size(); |
142 sink_discovery_callback_.Run( | 154 sink_discovery_callback_.Run(std::vector<MediaSinkInternal>( |
143 std::vector<MediaSinkInternal>(sinks.begin(), sinks.end())); | 155 current_sinks_.begin(), current_sinks_.end())); |
144 mrp_sinks_ = std::move(sinks); | 156 mrp_sinks_ = current_sinks_; |
| 157 } |
| 158 |
| 159 void DialMediaSinkService::StartTimer() { |
| 160 // Create a finish timer. |
| 161 if (!finish_timer_) |
| 162 finish_timer_.reset(new base::OneShotTimer()); |
| 163 |
| 164 base::TimeDelta finish_delay = |
| 165 base::TimeDelta::FromSeconds(kFetchCompleteTimeoutSecs); |
| 166 finish_timer_->Start(FROM_HERE, finish_delay, |
| 167 base::Bind(&DialMediaSinkService::OnFetchCompleted, |
| 168 base::Unretained(this))); |
145 } | 169 } |
146 | 170 |
147 } // namespace media_router | 171 } // namespace media_router |
OLD | NEW |