device/bluetooth: Add read_mtu as an argument of BluetoothAudioSinkDataAvailable.

device/bluetooth/bluetooth_audio_sink_chromeos_unittest.cc

 // Copyright 2015 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.
 
 #include <vector>
 
 #include "base/bind.h"
 #include "base/logging.h"
 #include "base/memory/ref_counted.h"
 #include "base/message_loop/message_loop.h"
@@ skipping 40 matching lines @@
     ++state_changed_count_;
   }
 
   void BluetoothAudioSinkVolumeChanged(BluetoothAudioSink* audio_sink,
                                        uint16_t volume) override {
     ++volume_changed_count_;
   }
 
   void BluetoothAudioSinkDataAvailable(BluetoothAudioSink* audio_sink,
                                        char* data,
-                                       size_t size) override {
+                                       size_t size,
+                                       uint16_t read_mtu) override {
     total_read_ += size;
     data_.clear();
     data_.insert(data_.begin(), data, data + size);
+    read_mtu_ = read_mtu;
   }
 
   int state_changed_count_;
   int volume_changed_count_;
   int data_available_count_;
   size_t total_read_;
   std::vector<char> data_;
+  uint16_t read_mtu_;
   BluetoothAudioSink::State state_;
 
  private:
   scoped_refptr<BluetoothAudioSink> audio_sink_;
 };
 
 class BluetoothAudioSinkChromeOSTest : public testing::Test {
  public:
   void SetUp() override {
     DBusThreadManager::Initialize();
@@ skipping 749 matching lines @@
 
   message_loop_.RunUntilIdle();
 
   // Acquire is called when the state of |audio_sink_| becomes STATE_PENDING,
   // and Acquire will trigger state change. Therefore, the state will be
   // STATE_ACTIVE right after STATE_PENDING.
   // State: STATE_IDLE -> STATE_PENDING -> STATE_ACTIVE
   EXPECT_EQ(observer_->state_changed_count_, 3);
   EXPECT_EQ(observer_->total_read_, data_one.size());
   EXPECT_EQ(observer_->data_, data_one);
+  EXPECT_EQ(observer_->read_mtu_, FakeBluetoothMediaTransportClient::kReadMtu);
 }
 
 // Tests the case where the remote device pauses and resume audio streaming.
 TEST_F(BluetoothAudioSinkChromeOSTest, PauseAndResume) {
   GetAudioSink();
 
   media_endpoint_->SelectConfiguration(
       std::vector<uint8_t>({0x21, 0x15, 0x33, 0x2C}),
       base::Bind(&BluetoothAudioSinkChromeOSTest::SelectConfigurationCallback,
                  base::Unretained(this)));
@@ skipping 15 matching lines @@
   EXPECT_EQ(observer_->volume_changed_count_, 1);
 
   fake_transport_->SetState(media_endpoint_->object_path(), "pending");
 
   std::vector<char> data_one(16, 0x12);
   fake_transport_->WriteData(media_endpoint_->object_path(), data_one);
 
   message_loop_.RunUntilIdle();
 
   EXPECT_EQ(observer_->data_, data_one);
+  EXPECT_EQ(observer_->read_mtu_, FakeBluetoothMediaTransportClient::kReadMtu);
   EXPECT_EQ(observer_->state_changed_count_, 3);
   EXPECT_EQ(observer_->total_read_, data_one.size());
 
   // Simulates the situation where the remote device pauses and resume audio
   // streaming.
   fake_transport_->SetState(media_endpoint_->object_path(), "idle");
 
   EXPECT_EQ(audio_sink_->GetState(), BluetoothAudioSink::STATE_IDLE);
   EXPECT_EQ(observer_->state_changed_count_, 4);
 
   fake_transport_->SetState(media_endpoint_->object_path(), "pending");
 
   std::vector<char> data_two(8, 0x10);
   fake_transport_->WriteData(media_endpoint_->object_path(), data_two);
 
   message_loop_.RunUntilIdle();
 
   EXPECT_EQ(observer_->data_, data_two);
+  EXPECT_EQ(observer_->read_mtu_, FakeBluetoothMediaTransportClient::kReadMtu);
   EXPECT_EQ(observer_->state_changed_count_, 6);
   EXPECT_EQ(observer_->total_read_, data_two.size());
 }
 
 TEST_F(BluetoothAudioSinkChromeOSTest, ContinuouslyStreaming) {
   GetAudioSink();
 
   media_endpoint_->SelectConfiguration(
       std::vector<uint8_t>({0x21, 0x15, 0x33, 0x2C}),
       base::Bind(&BluetoothAudioSinkChromeOSTest::SelectConfigurationCallback,
@@ skipping 16 matching lines @@
   EXPECT_EQ(observer_->volume_changed_count_, 1);
 
   fake_transport_->SetState(media_endpoint_->object_path(), "pending");
 
   std::vector<char> data_one(16, 0x12);
   fake_transport_->WriteData(media_endpoint_->object_path(), data_one);
 
   message_loop_.RunUntilIdle();
 
   EXPECT_EQ(observer_->data_, data_one);
+  EXPECT_EQ(observer_->read_mtu_, FakeBluetoothMediaTransportClient::kReadMtu);
   EXPECT_EQ(observer_->state_changed_count_, 3);
   EXPECT_EQ(observer_->total_read_, data_one.size());
 
   std::vector<char> data_two(8, 0x10);
   fake_transport_->WriteData(media_endpoint_->object_path(), data_two);
 
   message_loop_.RunUntilIdle();
 
   EXPECT_EQ(observer_->data_, data_two);
+  EXPECT_EQ(observer_->read_mtu_, FakeBluetoothMediaTransportClient::kReadMtu);
   EXPECT_EQ(observer_->state_changed_count_, 3);
   EXPECT_EQ(observer_->total_read_, data_one.size() + data_two.size());
 }
 
 }  // namespace chromeos