// Copyright 2021 The Chromium Authors
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#ifdef UNSAFE_BUFFERS_BUILD
// TODO(crbug.com/40285824): Remove this and convert code to safer constructs.
#pragma allow_unsafe_buffers
#endif
#include <initializer_list>
#include <memory>
#include <string>
#include <vector>
#include "ash/annotator/annotator_controller.h"
#include "ash/constants/ash_features.h"
#include "ash/projector/model/projector_session_impl.h"
#include "ash/projector/projector_controller_impl.h"
#include "ash/projector/projector_metadata_controller.h"
#include "ash/projector/projector_metrics.h"
#include "ash/projector/test/mock_projector_metadata_controller.h"
#include "ash/public/cpp/projector/projector_new_screencast_precondition.h"
#include "ash/public/cpp/projector/speech_recognition_availability.h"
#include "ash/public/cpp/test/mock_projector_client.h"
#include "ash/shell.h"
#include "ash/system/tray/tray_container.h"
#include "ash/test/ash_test_base.h"
#include "ash/webui/annotator/test/mock_annotator_client.h"
#include "ash/webui/projector_app/public/cpp/projector_app_constants.h"
#include "base/files/file.h"
#include "base/files/file_path.h"
#include "base/files/file_util.h"
#include "base/files/safe_base_name.h"
#include "base/files/scoped_temp_dir.h"
#include "base/functional/bind.h"
#include "base/functional/callback_forward.h"
#include "base/memory/raw_ptr.h"
#include "base/run_loop.h"
#include "base/test/bind.h"
#include "base/test/metrics/histogram_tester.h"
#include "base/test/scoped_feature_list.h"
#include "base/time/time.h"
#include "chromeos/ash/components/audio/cras_audio_handler.h"
#include "chromeos/ash/components/dbus/audio/audio_node.h"
#include "chromeos/ash/components/dbus/audio/fake_cras_audio_client.h"
#include "media/mojo/mojom/speech_recognition_result.h"
#include "testing/gtest/include/gtest/gtest.h"
#include "ui/gfx/image/image_unittest_util.h"
namespace ash {
namespace {
using testing::_;
using testing::ElementsAre;
struct AudioNodeInfo {
bool is_input;
uint64_t id;
const char* const device_name;
const char* const type;
const char* const name;
};
constexpr char kProjectorCreationFlowHistogramName[] =
"Ash.Projector.CreationFlow.ClamshellMode";
constexpr char kProjectorTranscriptsCountHistogramName[] =
"Ash.Projector.TranscriptsCount.ClamshellMode";
constexpr char kSpeechRecognitionEndStateOnDevice[] =
"Ash.Projector.SpeechRecognitionEndState.OnDevice";
constexpr char kSpeechRecognitionEndStateServerBased[] =
"Ash.Projector.SpeechRecognitionEndState.ServerBased";
constexpr char kMetadataFileName[] = "MyScreencast";
constexpr char kProjectorV2Extension[] = "screencast";
void NotifyControllerForFinalSpeechResult(ProjectorControllerImpl* controller) {
media::SpeechRecognitionResult result;
result.transcription = "transcript text 1";
result.is_final = true;
result.timing_information = media::TimingInformation();
result.timing_information->audio_start_time = base::Milliseconds(0);
result.timing_information->audio_end_time = base::Milliseconds(3000);
std::vector<media::HypothesisParts> hypothesis_parts;
std::string hypothesis_text[3] = {"transcript", "text", "1"};
int hypothesis_time[3] = {1000, 2000, 2500};
for (int i = 0; i < 3; i++) {
hypothesis_parts.emplace_back(
std::vector<std::string>({hypothesis_text[i]}),
base::Milliseconds(hypothesis_time[i]));
}
result.timing_information->hypothesis_parts = std::move(hypothesis_parts);
controller->OnTranscription(result);
}
void NotifyControllerForPartialSpeechResult(
ProjectorControllerImpl* controller) {
controller->OnTranscription(
media::SpeechRecognitionResult("transcript partial text 1", false));
}
class ProjectorMetadataControllerForTest : public ProjectorMetadataController {
public:
ProjectorMetadataControllerForTest() = default;
ProjectorMetadataControllerForTest(
const ProjectorMetadataControllerForTest&) = delete;
ProjectorMetadataControllerForTest& operator=(
const ProjectorMetadataControllerForTest&) = delete;
~ProjectorMetadataControllerForTest() override = default;
void SetRunLoopQuitClosure(base::RepeatingClosure closure) {
quit_closure_ = base::BindOnce(closure);
}
protected:
// ProjectorMetadataController:
void OnSaveFileResult(const base::FilePath& path,
size_t transcripts_count,
bool success) override {
ProjectorMetadataController::OnSaveFileResult(path, transcripts_count,
success);
std::move(quit_closure_).Run();
}
private:
base::OnceClosure quit_closure_;
};
} // namespace
class ProjectorControllerTest : public AshTestBase {
public:
ProjectorControllerTest()
: AshTestBase(base::test::TaskEnvironment::TimeSource::MOCK_TIME) {}
ProjectorControllerTest(const ProjectorControllerTest&) = delete;
ProjectorControllerTest& operator=(const ProjectorControllerTest&) = delete;
// AshTestBase:
void SetUp() override {
AshTestBase::SetUp();
controller_ =
static_cast<ProjectorControllerImpl*>(ProjectorController::Get());
auto mock_metadata_controller =
std::make_unique<MockProjectorMetadataController>();
mock_metadata_controller_ = mock_metadata_controller.get();
controller_->SetProjectorMetadataControllerForTest(
std::move(mock_metadata_controller));
SpeechRecognitionAvailability availability;
availability.on_device_availability =
OnDeviceRecognitionAvailability::kAvailable;
ON_CALL(mock_client_, GetSpeechRecognitionAvailability)
.WillByDefault(testing::Return(availability));
controller_->SetClient(&mock_client_);
auto* annotator_controller = Shell::Get()->annotator_controller();
annotator_controller->SetToolClient(&mock_annotator_client_);
}
void InitializeRealMetadataController() {
std::unique_ptr<ProjectorMetadataController> metadata_controller =
std::make_unique<ProjectorMetadataControllerForTest>();
metadata_controller_ = static_cast<ProjectorMetadataControllerForTest*>(
metadata_controller.get());
controller_->SetProjectorMetadataControllerForTest(
std::move(metadata_controller));
}
protected:
void InitFakeMic(bool mic_present) {
if (!mic_present) {
CrasAudioHandler::Get()->SetActiveInputNodes({});
return;
}
const AudioNodeInfo kInternalMic[] = {
{true, 55555, "Fake Mic", "INTERNAL_MIC", "Internal Mic"}};
const AudioNode audio_node =
AudioNode(kInternalMic->is_input, kInternalMic->id,
/*has_v2_stable_device_id=*/false, kInternalMic->id,
/*stable_device_id_v2=*/0, kInternalMic->device_name,
kInternalMic->type, kInternalMic->name, /*active=*/false,
/*plugged_time=*/0, /*max_supported_channels=*/1,
/*audio_effect=*/1, /*number_of_volume_steps=*/25);
FakeCrasAudioClient::Get()->SetAudioNodesForTesting({audio_node});
CrasAudioHandler::Get()->SetActiveInputNodes({kInternalMic->id});
}
raw_ptr<MockProjectorMetadataController, DanglingUntriaged>
mock_metadata_controller_ = nullptr;
raw_ptr<ProjectorMetadataControllerForTest, DanglingUntriaged>
metadata_controller_;
raw_ptr<ProjectorControllerImpl, DanglingUntriaged> controller_;
MockProjectorClient mock_client_;
MockAnnotatorClient mock_annotator_client_;
base::HistogramTester histogram_tester_;
base::ScopedTempDir temp_dir_;
base::test::ScopedFeatureList scoped_feature_list_;
};
TEST_F(ProjectorControllerTest, OnTranscription) {
// Verify that |RecordTranscription| in |ProjectorMetadataController| is
// called to record the transcript.
EXPECT_CALL(*mock_metadata_controller_, RecordTranscription(_)).Times(1);
NotifyControllerForFinalSpeechResult(controller_);
}
TEST_F(ProjectorControllerTest, OnTranscriptionPartialResult) {
// Verify that |RecordTranscription| in |ProjectorMetadataController| is not
// called since it is not a final result.
EXPECT_CALL(*mock_metadata_controller_, RecordTranscription(_)).Times(0);
NotifyControllerForPartialSpeechResult(controller_);
}
TEST_F(ProjectorControllerTest, OnAudioNodesChanged) {
ON_CALL(mock_client_, IsDriveFsMounted())
.WillByDefault(testing::Return(true));
InitFakeMic(/*mic_present=*/true);
EXPECT_CALL(mock_client_,
OnNewScreencastPreconditionChanged(NewScreencastPrecondition(
NewScreencastPreconditionState::kEnabled,
{NewScreencastPreconditionReason::kEnabledBySoda})));
controller_->OnAudioNodesChanged();
InitFakeMic(/*mic_present=*/false);
EXPECT_CALL(mock_client_,
OnNewScreencastPreconditionChanged(NewScreencastPrecondition(
NewScreencastPreconditionState::kDisabled,
{NewScreencastPreconditionReason::kNoMic})));
controller_->OnAudioNodesChanged();
}
TEST_F(ProjectorControllerTest, OnSpeechRecognitionAvailabilityChanged) {
SpeechRecognitionAvailability availability;
// Soda is not available.
availability.use_on_device = true;
availability.on_device_availability =
OnDeviceRecognitionAvailability::kSodaNotAvailable;
ON_CALL(mock_client_, GetSpeechRecognitionAvailability)
.WillByDefault(testing::Return(availability));
ON_CALL(mock_client_, IsDriveFsMounted())
.WillByDefault(testing::Return(true));
EXPECT_CALL(mock_client_,
OnNewScreencastPreconditionChanged(NewScreencastPrecondition(
NewScreencastPreconditionState::kDisabled,
{NewScreencastPreconditionReason::
kOnDeviceSpeechRecognitionNotSupported})));
controller_->OnSpeechRecognitionAvailabilityChanged();
// Soda is available.
availability.on_device_availability =
OnDeviceRecognitionAvailability::kAvailable;
ON_CALL(mock_client_, GetSpeechRecognitionAvailability)
.WillByDefault(testing::Return(availability));
EXPECT_CALL(mock_client_,
OnNewScreencastPreconditionChanged(NewScreencastPrecondition(
NewScreencastPreconditionState::kEnabled,
{NewScreencastPreconditionReason::kEnabledBySoda})));
controller_->OnSpeechRecognitionAvailabilityChanged();
// Server based available.
availability.use_on_device = false;
availability.server_based_availability =
ServerBasedRecognitionAvailability::kAvailable;
ON_CALL(mock_client_, GetSpeechRecognitionAvailability)
.WillByDefault(testing::Return(availability));
EXPECT_CALL(mock_client_,
OnNewScreencastPreconditionChanged(NewScreencastPrecondition(
NewScreencastPreconditionState::kEnabled,
{NewScreencastPreconditionReason::
kEnabledByServerSideSpeechRecognition})));
controller_->OnSpeechRecognitionAvailabilityChanged();
}
TEST_F(ProjectorControllerTest, RecordingStarted) {
EXPECT_CALL(mock_client_, StartSpeechRecognition());
EXPECT_CALL(*mock_metadata_controller_, OnRecordingStarted());
auto* root = Shell::GetPrimaryRootWindow();
controller_->projector_session()->Start(
base::SafeBaseName::Create("projector_data").value());
histogram_tester_.ExpectUniqueSample(
kProjectorCreationFlowHistogramName,
/*sample=*/ProjectorCreationFlow::kSessionStarted,
/*expected_bucket_count=*/1);
controller_->OnRecordingStarted(root);
histogram_tester_.ExpectBucketCount(
kProjectorCreationFlowHistogramName,
/*sample=*/ProjectorCreationFlow::kRecordingStarted,
/*expected_count=*/1);
}
TEST_F(ProjectorControllerTest, RecordingEnded) {
base::FilePath screencast_container_path;
ASSERT_TRUE(mock_client_.GetBaseStoragePath(&screencast_container_path));
ON_CALL(mock_client_, IsDriveFsMounted())
.WillByDefault(testing::Return(true));
EXPECT_CALL(mock_client_, OpenProjectorApp()).Times(0);
EXPECT_CALL(mock_client_,
OnNewScreencastPreconditionChanged(NewScreencastPrecondition(
NewScreencastPreconditionState::kDisabled,
{NewScreencastPreconditionReason::kInProjectorSession})));
controller_->projector_session()->Start(
base::SafeBaseName::Create("projector_data").value());
histogram_tester_.ExpectUniqueSample(
kProjectorCreationFlowHistogramName,
/*sample=*/ProjectorCreationFlow::kSessionStarted,
/*expected_bucket_count=*/1);
controller_->OnRecordingStarted(Shell::GetPrimaryRootWindow());
histogram_tester_.ExpectBucketCount(
kProjectorCreationFlowHistogramName,
/*sample=*/ProjectorCreationFlow::kRecordingStarted,
/*expected_count=*/1);
base::RunLoop runLoop;
controller_->CreateScreencastContainerFolder(base::BindLambdaForTesting(
[&](const base::FilePath& screencast_file_path_no_extension) {
// Expects screencast files name equals to it's parent folder name:
EXPECT_EQ(screencast_file_path_no_extension.BaseName(),
screencast_file_path_no_extension.DirName().BaseName());
EXPECT_CALL(
mock_client_,
OnNewScreencastPreconditionChanged(NewScreencastPrecondition(
NewScreencastPreconditionState::kEnabled,
{NewScreencastPreconditionReason::kEnabledBySoda})))
.Times(0);
EXPECT_CALL(mock_client_, StopSpeechRecognition())
.WillOnce(testing::Invoke([&]() {
controller_->OnSpeechRecognitionStopped(/*forced=*/false);
}));
EXPECT_CALL(*mock_metadata_controller_, SaveMetadata(_)).Times(0);
controller_->OnRecordingEnded();
runLoop.Quit();
}));
runLoop.Run();
histogram_tester_.ExpectBucketCount(
kProjectorCreationFlowHistogramName,
/*sample=*/ProjectorCreationFlow::kRecordingEnded, /*expected_count=*/1);
histogram_tester_.ExpectTotalCount(kProjectorCreationFlowHistogramName,
/*expected_count=*/3);
}
enum class RecognitionEndLatency {
// The speech recognition has ended even before recording
// has wrapped up dlp check.
kImmediate,
// The speech recognition ends after recording has wrapped up dlp check
// but fore the restricted timeout.
kDelayed,
// The speech recognition doesn't end and it causes a time out.
kDelayedCausingTimeout
};
class ProjectorOnDlpRestrictionCheckedAtVideoEndTest
: public ::testing::WithParamInterface<
::testing::tuple<RecognitionEndLatency, bool>>,
public ProjectorControllerTest {
public:
ProjectorOnDlpRestrictionCheckedAtVideoEndTest() = default;
ProjectorOnDlpRestrictionCheckedAtVideoEndTest(
const ProjectorOnDlpRestrictionCheckedAtVideoEndTest&) = delete;
ProjectorOnDlpRestrictionCheckedAtVideoEndTest& operator=(
const ProjectorOnDlpRestrictionCheckedAtVideoEndTest&) = delete;
~ProjectorOnDlpRestrictionCheckedAtVideoEndTest() override = default;
};
TEST_P(ProjectorOnDlpRestrictionCheckedAtVideoEndTest, WrapUpRecordingOnce) {
bool wrap_up_by_speech_stopped;
bool transcript_end_timed_out;
switch (std::get<0>(GetParam())) {
case RecognitionEndLatency::kImmediate:
wrap_up_by_speech_stopped = false;
transcript_end_timed_out = false;
break;
case RecognitionEndLatency::kDelayed:
wrap_up_by_speech_stopped = true;
transcript_end_timed_out = false;
break;
case RecognitionEndLatency::kDelayedCausingTimeout:
wrap_up_by_speech_stopped = true;
transcript_end_timed_out = true;
break;
}
bool user_deleted_video_file = std::get<1>(GetParam());
base::FilePath screencast_container_path;
ASSERT_TRUE(mock_client_.GetBaseStoragePath(&screencast_container_path));
ON_CALL(mock_client_, IsDriveFsMounted())
.WillByDefault(testing::Return(true));
EXPECT_CALL(mock_client_, OpenProjectorApp());
EXPECT_CALL(mock_client_,
OnNewScreencastPreconditionChanged(NewScreencastPrecondition(
NewScreencastPreconditionState::kDisabled,
{NewScreencastPreconditionReason::kInProjectorSession})));
// Advance clock to 20:02:10 Jan 2nd, 2021.
base::Time start_time;
EXPECT_TRUE(base::Time::FromString("2 Jan 2021 20:02:10", &start_time));
base::TimeDelta forward_by = start_time - base::Time::Now();
task_environment()->AdvanceClock(forward_by);
controller_->projector_session()->Start(
base::SafeBaseName::Create("projector_data").value());
histogram_tester_.ExpectUniqueSample(
kProjectorCreationFlowHistogramName,
/*sample=*/ProjectorCreationFlow::kSessionStarted,
/*expected_bucket_count=*/1);
controller_->OnRecordingStarted(Shell::GetPrimaryRootWindow());
histogram_tester_.ExpectBucketCount(
kProjectorCreationFlowHistogramName,
/*sample=*/ProjectorCreationFlow::kRecordingStarted,
/*expected_count=*/1);
base::RunLoop runLoop;
controller_->CreateScreencastContainerFolder(base::BindLambdaForTesting(
[&](const base::FilePath& screencast_file_path_no_extension) {
EXPECT_CALL(
mock_client_,
OnNewScreencastPreconditionChanged(NewScreencastPrecondition(
NewScreencastPreconditionState::kEnabled,
{NewScreencastPreconditionReason::kEnabledBySoda})));
const std::string expected_screencast_name =
"Screencast 2021-01-02 20.02.10";
const base::FilePath expected_path =
screencast_container_path.Append("root")
.Append("projector_data")
// Screencast container folder.
.Append(expected_screencast_name)
// Screencast file name without extension.
.Append(expected_screencast_name);
controller_->OnRecordingEnded();
if (!user_deleted_video_file) {
// Verify that |SaveMetadata| in |ProjectorMetadataController| is
// called with the expected path.
EXPECT_EQ(screencast_file_path_no_extension, expected_path);
// Verify that save metadata only triggered once. The path will not
// change as the clock advances.
task_environment()->AdvanceClock(base::Minutes(1));
int expected_count = wrap_up_by_speech_stopped ? 2 : 1;
EXPECT_CALL(*mock_metadata_controller_, SaveMetadata(expected_path))
.Times(expected_count);
// Verify that thumbnail file is saved.
controller_->SetOnFileSavedCallbackForTest(base::BindLambdaForTesting(
[&](const base::FilePath& path, bool success) {
EXPECT_TRUE(success);
EXPECT_TRUE(base::PathExists(path));
}));
} else {
// Verify that save metadata is not triggered.
EXPECT_CALL(*mock_metadata_controller_, SaveMetadata(_)).Times(0);
// Expects notification gets resumed if recording deleted.
const std::vector<base::FilePath> screencast_files = {
expected_path.AddExtension(kProjectorV2MetadataFileExtension),
expected_path.AddExtension(kProjectorMediaFileExtension),
expected_path.DirName().Append(
kScreencastDefaultThumbnailFileName)};
EXPECT_CALL(mock_client_, ToggleFileSyncingNotificationForPaths(
screencast_files, /*suppress=*/false));
// Verify that Projector Folder is cleaned up.
controller_->SetOnPathDeletedCallbackForTest(
base::BindLambdaForTesting(
[&](const base::FilePath& path, bool success) {
EXPECT_TRUE(success);
EXPECT_FALSE(base::PathExists(path));
}));
}
auto image = gfx::test::CreateImageSkia(10, 10);
if (wrap_up_by_speech_stopped) {
controller_->OnVideoFileFinalized(
/*user_deleted_video_file=*/user_deleted_video_file,
/*thumbnail=*/image);
if (!transcript_end_timed_out) {
controller_->OnSpeechRecognitionStopped(/*forced=*/false);
} else {
EXPECT_CALL(mock_client_, ForceEndSpeechRecognition())
.Times(1)
.WillOnce(testing::Invoke([&]() {
controller_->OnSpeechRecognitionStopped(/*forced=*/true);
}));
// Simulate that the timer has fired.
EXPECT_TRUE(controller_->get_timer_for_testing()->IsRunning());
controller_->get_timer_for_testing()->FireNow();
}
} else {
controller_->OnSpeechRecognitionStopped(/*forced=*/false);
controller_->OnVideoFileFinalized(
/*user_deleted_video_file=*/user_deleted_video_file,
/*thumbnail=*/image);
}
runLoop.Quit();
}));
runLoop.Run();
histogram_tester_.ExpectTotalCount(kProjectorCreationFlowHistogramName,
/*expected_count=*/4);
}
INSTANTIATE_TEST_SUITE_P(
WrapUpRecordingOnce,
ProjectorOnDlpRestrictionCheckedAtVideoEndTest,
::testing::Combine(
::testing::ValuesIn({RecognitionEndLatency::kImmediate,
RecognitionEndLatency::kDelayed,
RecognitionEndLatency::kDelayedCausingTimeout}),
::testing::Bool()));
TEST_F(ProjectorControllerTest, NoTranscriptsTest) {
InitializeRealMetadataController();
metadata_controller_->OnRecordingStarted();
base::RunLoop run_loop;
metadata_controller_->SetRunLoopQuitClosure(run_loop.QuitClosure());
// Simulate ending the recording and saving the metadata file.
ASSERT_TRUE(temp_dir_.CreateUniqueTempDir());
base::FilePath metadata_file(temp_dir_.GetPath().Append(kMetadataFileName));
metadata_controller_->SaveMetadata(metadata_file);
run_loop.Run();
histogram_tester_.ExpectUniqueSample(kProjectorTranscriptsCountHistogramName,
/*sample=*/0, /*count=*/1);
// Verify the written metadata file size is between 0-100 bytes. Change this
// limit as needed if you make significant changes to the metadata file.
base::File file(metadata_file.AddExtension(kProjectorV2Extension),
base::File::FLAG_OPEN | base::File::FLAG_READ);
EXPECT_GT(file.GetLength(), 0);
EXPECT_LT(file.GetLength(), 100);
}
TEST_F(ProjectorControllerTest, TranscriptsTest) {
InitializeRealMetadataController();
metadata_controller_->OnRecordingStarted();
base::RunLoop run_loop;
metadata_controller_->SetRunLoopQuitClosure(run_loop.QuitClosure());
// Simulate adding some transcripts.
NotifyControllerForFinalSpeechResult(controller_);
NotifyControllerForFinalSpeechResult(controller_);
// Simulate ending the recording and saving the metadata file.
ASSERT_TRUE(temp_dir_.CreateUniqueTempDir());
base::FilePath metadata_file(temp_dir_.GetPath().Append(kMetadataFileName));
metadata_controller_->SaveMetadata(metadata_file);
run_loop.Run();
histogram_tester_.ExpectUniqueSample(kProjectorTranscriptsCountHistogramName,
/*sample=*/2, /*count=*/1);
// Verify the written metadata file size is between 400-500 bytes. This file
// should be larger than the one in the NoTranscriptsTest above. Change this
// limit as needed if you make significant changes to the metadata file.
base::File file(metadata_file.AddExtension(kProjectorV2Extension),
base::File::FLAG_OPEN | base::File::FLAG_READ);
EXPECT_GT(file.GetLength(), 400);
EXPECT_LT(file.GetLength(), 500);
}
TEST_F(ProjectorControllerTest, V2TranscriptsTest) {
InitializeRealMetadataController();
metadata_controller_->OnRecordingStarted();
base::RunLoop run_loop;
metadata_controller_->SetRunLoopQuitClosure(run_loop.QuitClosure());
// Simulate adding some transcripts.
NotifyControllerForFinalSpeechResult(controller_);
NotifyControllerForFinalSpeechResult(controller_);
// Simulate ending the recording and saving the metadata file.
ASSERT_TRUE(temp_dir_.CreateUniqueTempDir());
base::FilePath metadata_file(temp_dir_.GetPath().Append(kMetadataFileName));
metadata_controller_->SaveMetadata(metadata_file);
run_loop.Run();
histogram_tester_.ExpectUniqueSample(kProjectorTranscriptsCountHistogramName,
/*sample=*/2, /*count=*/1);
// Verify the written metadata file size is between 400-500 bytes. This file
// should be larger than the one in the NoTranscriptsTest above. Change this
// limit as needed if you make significant changes to the metadata file.
base::File file(metadata_file.AddExtension(kProjectorV2Extension),
base::File::FLAG_OPEN | base::File::FLAG_READ);
EXPECT_GT(file.GetLength(), 400);
EXPECT_LT(file.GetLength(), 500);
}
TEST_F(ProjectorControllerTest, OnDriveMountFailed) {
ON_CALL(mock_client_, IsDriveFsMountFailed())
.WillByDefault(testing::Return(true));
ON_CALL(mock_client_, IsDriveFsMounted())
.WillByDefault(testing::Return(false));
EXPECT_EQ(NewScreencastPrecondition(
NewScreencastPreconditionState::kDisabled,
{NewScreencastPreconditionReason::kDriveFsMountFailed}),
controller_->GetNewScreencastPrecondition());
}
TEST_F(ProjectorControllerTest, SuppressDriveNotification) {
ON_CALL(mock_client_, IsDriveFsMounted())
.WillByDefault(testing::Return(true));
base::FilePath mounted_path;
ASSERT_TRUE(mock_client_.GetBaseStoragePath(&mounted_path));
// The screencast name, which is used to form the screencast folder/files
// paths, is generated on projector session starts
auto* projector_session = controller_->projector_session();
projector_session->Start(
base::SafeBaseName::Create("projector_data").value());
const base::FilePath expect_container_path =
mounted_path.Append("root")
.Append(projector_session->storage_dir())
.Append(projector_session->screencast_name());
const base::FilePath expected_path_with_no_extension =
expect_container_path.Append(projector_session->screencast_name());
const std::vector<base::FilePath> screencast_files = {
expected_path_with_no_extension.AddExtension(
kProjectorV2MetadataFileExtension),
expected_path_with_no_extension.AddExtension(
kProjectorMediaFileExtension),
expect_container_path.Append(kScreencastDefaultThumbnailFileName)};
// Expects notification gets suppressed when creating screencast folder.
EXPECT_CALL(mock_client_, ToggleFileSyncingNotificationForPaths(
screencast_files, /*suppress=*/true))
.Times(1);
base::RunLoop run_loop;
controller_->CreateScreencastContainerFolder(base::BindLambdaForTesting(
[&](const base::FilePath& screencast_file_path_no_extension) {
EXPECT_EQ(expected_path_with_no_extension,
screencast_file_path_no_extension);
// Expects notification gets resumed if recording is aborted.
EXPECT_CALL(mock_client_, ToggleFileSyncingNotificationForPaths(
screencast_files, /*suppress=*/false))
.Times(1);
// Simulates starting abort called by capture mode.
controller_->OnRecordingStartAborted();
run_loop.Quit();
}));
run_loop.Run();
}
// Used to test SpeechRecognitionEndState metric for both on-device and
// server based speech recognition.
class ProjectorSpeechRecognitionEndTest
: public ::testing::WithParamInterface<bool>,
public ProjectorControllerTest {
public:
ProjectorSpeechRecognitionEndTest() = default;
ProjectorSpeechRecognitionEndTest(const ProjectorSpeechRecognitionEndTest&) =
delete;
ProjectorSpeechRecognitionEndTest& operator=(
const ProjectorSpeechRecognitionEndTest&) = delete;
~ProjectorSpeechRecognitionEndTest() override = default;
};
TEST_P(ProjectorSpeechRecognitionEndTest, SpeechRecognitionEndMetric) {
SpeechRecognitionAvailability availability;
availability.on_device_availability =
OnDeviceRecognitionAvailability::kAvailable;
availability.server_based_availability =
ServerBasedRecognitionAvailability::kAvailable;
availability.use_on_device = GetParam();
ON_CALL(mock_client_, GetSpeechRecognitionAvailability)
.WillByDefault(testing::Return(availability));
const std::string histogram_name =
availability.use_on_device ? kSpeechRecognitionEndStateOnDevice
: kSpeechRecognitionEndStateServerBased;
auto* projector_session = controller_->projector_session();
projector_session->Start(
base::SafeBaseName::Create("projector_data").value());
auto* root = Shell::GetPrimaryRootWindow();
// Tests speech recognition encountering an error during session.
controller_->OnRecordingStarted(root);
controller_->OnTranscriptionError();
histogram_tester_.ExpectBucketCount(
histogram_name,
SpeechRecognitionEndState::kSpeechRecognitionEnounteredError,
/*expected_count=*/1);
// Tests speech recognition successfully stopping.
ON_CALL(mock_client_, StopSpeechRecognition)
.WillByDefault(testing::Invoke([&]() {
controller_->OnSpeechRecognitionStopped(/*forced=*/false);
}));
controller_->OnRecordingStarted(root);
controller_->OnRecordingEnded();
histogram_tester_.ExpectBucketCount(
histogram_name,
SpeechRecognitionEndState::kSpeechRecognitionSuccessfullyStopped,
/*expected_count=*/1);
// Tests speech recognition forced stopped.
ON_CALL(mock_client_, StopSpeechRecognition).WillByDefault(testing::Return());
EXPECT_CALL(mock_client_, ForceEndSpeechRecognition())
.Times(1)
.WillOnce(testing::Invoke(
[&]() { controller_->OnSpeechRecognitionStopped(/*forced=*/true); }));
controller_->OnRecordingStarted(root);
controller_->OnRecordingEnded();
controller_->get_timer_for_testing()->FireNow();
histogram_tester_.ExpectBucketCount(
histogram_name,
SpeechRecognitionEndState::kSpeechRecognitionForcedStopped,
/*expected_count=*/1);
// Tests speech recognition encountering error while stopping.
controller_->OnRecordingStarted(root);
controller_->OnRecordingEnded();
controller_->OnTranscriptionError();
histogram_tester_.ExpectBucketCount(
histogram_name,
SpeechRecognitionEndState::
kSpeechRecognitionEncounteredErrorWhileStopping,
/*expected_count=*/1);
}
INSTANTIATE_TEST_SUITE_P(SpeechRecognitionEndMetric,
ProjectorSpeechRecognitionEndTest,
/*use_on_device=*/::testing::Bool());
} // namespace ash
Codebase Browser
chromium