// Copyright 2013 The Chromium Authors
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#include "chrome/browser/local_discovery/service_discovery_client.h"
#import <Cocoa/Cocoa.h>
#include <stdint.h>
#include "base/containers/contains.h"
#include "base/functional/bind.h"
#include "base/functional/callback.h"
#include "base/run_loop.h"
#include "base/test/metrics/histogram_tester.h"
#include "base/threading/thread.h"
#include "chrome/browser/local_discovery/service_discovery_client_mac.h"
#include "chrome/browser/local_discovery/service_discovery_client_mac_util.h"
#import "chrome/browser/ui/cocoa/test/cocoa_test_helper.h"
#include "content/public/test/browser_task_environment.h"
#include "net/base/ip_endpoint.h"
#include "net/base/sockaddr_storage.h"
#include "testing/gtest_mac.h"
@interface TestNSNetService : NSNetService {
@private
NSData* __strong _data;
NSArray* __strong _addresses;
}
- (instancetype)initWithData:(NSData*)data;
- (void)setAddresses:(NSArray*)addresses;
@end
@implementation TestNSNetService
- (instancetype)initWithData:(NSData*)data {
if ((self = [super initWithDomain:@"" type:@"_tcp." name:@"Test.123"])) {
_data = data;
}
return self;
}
- (void)setAddresses:(NSArray*)addresses {
_addresses = [addresses copy];
}
- (NSArray*)addresses {
return _addresses;
}
- (NSData*)TXTRecordData {
return _data;
}
@end
namespace local_discovery {
class ServiceDiscoveryClientMacTest : public CocoaTest {
public:
ServiceDiscoveryClientMacTest()
: client_(new ServiceDiscoveryClientMac()),
num_updates_(0),
num_resolves_(0) {
}
void OnServiceUpdated(
ServiceWatcher::UpdateType update,
const std::string& service_name) {
last_update_ = update;
last_service_name_ = service_name;
num_updates_++;
}
void OnResolveComplete(
ServiceResolver::RequestStatus status,
const ServiceDescription& service_description) {
last_status_ = status;
last_service_description_ = service_description;
num_resolves_++;
}
ServiceDiscoveryClient* client() { return client_.get(); }
protected:
content::BrowserTaskEnvironment task_environment_;
scoped_refptr<ServiceDiscoveryClientMac> client_;
ServiceWatcher::UpdateType last_update_;
std::string last_service_name_;
int num_updates_;
ServiceResolver::RequestStatus last_status_;
ServiceDescription last_service_description_;
int num_resolves_;
};
TEST_F(ServiceDiscoveryClientMacTest, ServiceWatcher) {
const std::string test_service_type = "_testing._tcp.local";
const std::string test_service_name = "Test.123";
std::unique_ptr<ServiceWatcher> watcher = client()->CreateServiceWatcher(
test_service_type,
base::BindRepeating(&ServiceDiscoveryClientMacTest::OnServiceUpdated,
base::Unretained(this)));
watcher->Start();
// Weak pointer to implementation class.
ServiceWatcherImplMac* watcher_impl =
static_cast<ServiceWatcherImplMac*>(watcher.get());
// Simulate service update events.
watcher_impl->OnServicesUpdate(
ServiceWatcher::UPDATE_ADDED, test_service_name);
watcher_impl->OnServicesUpdate(
ServiceWatcher::UPDATE_CHANGED, test_service_name);
watcher_impl->OnServicesUpdate(
ServiceWatcher::UPDATE_REMOVED, test_service_name);
EXPECT_EQ(last_service_name_, test_service_name + "." + test_service_type);
EXPECT_EQ(num_updates_, 3);
}
TEST_F(ServiceDiscoveryClientMacTest, DeleteWatcherAfterStart) {
const std::string test_service_type = "_testing._tcp.local";
std::unique_ptr<ServiceWatcher> watcher = client()->CreateServiceWatcher(
test_service_type,
base::BindRepeating(&ServiceDiscoveryClientMacTest::OnServiceUpdated,
base::Unretained(this)));
watcher->Start();
watcher.reset();
EXPECT_EQ(0, num_updates_);
}
TEST_F(ServiceDiscoveryClientMacTest, DeleteResolverAfterStart) {
const std::string test_service_name = "Test.123";
std::unique_ptr<ServiceResolver> resolver = client()->CreateServiceResolver(
test_service_name,
base::BindRepeating(&ServiceDiscoveryClientMacTest::OnResolveComplete,
base::Unretained(this)));
resolver->StartResolving();
resolver.reset();
EXPECT_EQ(0, num_resolves_);
}
TEST_F(ServiceDiscoveryClientMacTest, ParseServiceRecord) {
const uint8_t record_bytes[] = {2, 'a', 'b', 3, 'd', '=', 'e'};
TestNSNetService* test_service = [[TestNSNetService alloc]
initWithData:[NSData dataWithBytes:record_bytes
length:std::size(record_bytes)]];
const std::string kIp = "2001:4860:4860::8844";
const uint16_t kPort = 4321;
net::IPAddress ip_address;
ASSERT_TRUE(ip_address.AssignFromIPLiteral(kIp));
net::IPEndPoint endpoint(ip_address, kPort);
net::SockaddrStorage storage;
ASSERT_TRUE(endpoint.ToSockAddr(storage.addr, &storage.addr_len));
NSData* discoveryHost =
[NSData dataWithBytes:storage.addr length:storage.addr_len];
NSArray* addresses = @[ discoveryHost ];
[test_service setAddresses:addresses];
ServiceDescription description;
ParseNetService(test_service, description);
const std::vector<std::string>& metadata = description.metadata;
EXPECT_EQ(2u, metadata.size());
EXPECT_TRUE(base::Contains(metadata, "ab"));
EXPECT_TRUE(base::Contains(metadata, "d=e"));
EXPECT_EQ(ip_address, description.ip_address);
EXPECT_EQ(kPort, description.address.port());
EXPECT_EQ(kIp, description.address.host());
}
// https://crbug.com/586628
TEST_F(ServiceDiscoveryClientMacTest, ParseInvalidUnicodeRecord) {
const uint8_t record_bytes[] = {
3, 'a', '=', 'b',
// The bytes after name= are the UTF-8 encoded representation of
// U+1F4A9, with the first two bytes of the code unit sequence transposed.
9, 'n', 'a', 'm', 'e', '=', 0x9F, 0xF0, 0x92, 0xA9,
5, 'c', 'd', '=', 'e', '9',
};
TestNSNetService* test_service = [[TestNSNetService alloc]
initWithData:[NSData dataWithBytes:record_bytes
length:std::size(record_bytes)]];
const std::string kIp = "2001:4860:4860::8844";
const uint16_t kPort = 4321;
net::IPAddress ip_address;
ASSERT_TRUE(ip_address.AssignFromIPLiteral(kIp));
net::IPEndPoint endpoint(ip_address, kPort);
net::SockaddrStorage storage;
ASSERT_TRUE(endpoint.ToSockAddr(storage.addr, &storage.addr_len));
NSData* discovery_host =
[NSData dataWithBytes:storage.addr length:storage.addr_len];
NSArray* addresses = @[ discovery_host ];
[test_service setAddresses:addresses];
ServiceDescription description;
ParseNetService(test_service, description);
const std::vector<std::string>& metadata = description.metadata;
EXPECT_EQ(2u, metadata.size());
EXPECT_TRUE(base::Contains(metadata, "a=b"));
EXPECT_TRUE(base::Contains(metadata, "cd=e9"));
EXPECT_EQ(ip_address, description.ip_address);
EXPECT_EQ(kPort, description.address.port());
EXPECT_EQ(kIp, description.address.host());
}
TEST_F(ServiceDiscoveryClientMacTest, ResolveInvalidServiceName) {
base::RunLoop run_loop;
// This is the same invalid U+1F4A9 code unit sequence as in
// ResolveInvalidUnicodeRecord.
const std::string test_service_name =
"Test\x9F\xF0\x92\xA9.123._testing._tcp.local";
std::unique_ptr<ServiceResolver> resolver = client()->CreateServiceResolver(
test_service_name, base::BindOnce(
[](ServiceDiscoveryClientMacTest* test,
base::OnceClosure quit_closure,
ServiceResolver::RequestStatus status,
const ServiceDescription& service_description) {
test->OnResolveComplete(status,
service_description);
std::move(quit_closure).Run();
},
base::Unretained(this), run_loop.QuitClosure()));
resolver->StartResolving();
run_loop.Run();
EXPECT_EQ(1, num_resolves_);
EXPECT_EQ(ServiceResolver::STATUS_KNOWN_NONEXISTENT, last_status_);
}
TEST_F(ServiceDiscoveryClientMacTest, RecordPermissionStateMetrics) {
base::HistogramTester histograms;
auto watcher_impl = std::make_unique<ServiceWatcherImplMac>(
"service_type", base::DoNothing(),
base::SingleThreadTaskRunner::GetCurrentDefault());
watcher_impl->RecordPermissionState(/*permission_granted*/ false);
histograms.ExpectUniqueSample(
"MediaRouter.Discovery.LocalNetworkAccessPermissionGranted", false, 1);
watcher_impl->RecordPermissionState(/*permission_granted*/ false);
histograms.ExpectUniqueSample(
"MediaRouter.Discovery.LocalNetworkAccessPermissionGranted", false, 1);
}
} // namespace local_discovery
Codebase Browser
chromium