media/capture/video/linux/video_capture_device_chromeos.cc - Issue 2143903003: [WIP] Move media/capture to device/capture

Side by Side Diff: media/capture/video/linux/video_capture_device_chromeos.cc

Issue 2143903003: [WIP] Move media/capture to device/capture (Closed) Base URL: https://chromium.googlesource.com/chromium/src.git@master

Patch Set: Created 4 years, 5 months ago

Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.

Jump to:

View unified diff | Download patch

« no previous file with comments | « media/capture/video/linux/video_capture_device_chromeos.h ('k') | media/capture/video/linux/video_capture_device_factory_linux.h » ('j') | no next file with comments »
Toggle Intra-line Diffs ('i') | Expand Comments ('e') | Collapse Comments ('c') | Hide Comments ('s')

OLD	NEW
	(Empty)
1 // Copyright 2014 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 "media/capture/video/linux/video_capture_device_chromeos.h"

6

7 #include <stdint.h>

8

9 #include "base/bind.h"

10 #include "base/macros.h"

11 #include "base/memory/ref_counted.h"

12 #include "base/single_thread_task_runner.h"

13 #include "base/threading/thread_task_runner_handle.h"

14 #include "ui/display/display.h"

15 #include "ui/display/display_observer.h"

16 #include "ui/display/screen.h"

17

18 namespace media {

19

20 // This is a delegate class used to transfer Display change events from the UI

21 // thread to the media thread.

22 class VideoCaptureDeviceChromeOS::ScreenObserverDelegate

23 : public display::DisplayObserver,

24 public base::RefCountedThreadSafe<ScreenObserverDelegate> {

25 public:

26 ScreenObserverDelegate(

27 VideoCaptureDeviceChromeOS* capture_device,

28 scoped_refptr<base::SingleThreadTaskRunner> ui_task_runner)

29 : capture_device_(capture_device),

30 ui_task_runner_(ui_task_runner),

31 capture_task_runner_(base::ThreadTaskRunnerHandle::Get()) {

32 ui_task_runner_->PostTask(

33 FROM_HERE,

34 base::Bind(&ScreenObserverDelegate::AddObserverOnUIThread, this));

35 }

36

37 void RemoveObserver() {

38 DCHECK(capture_task_runner_->BelongsToCurrentThread());

39 capture_device_ = NULL;

40 ui_task_runner_->PostTask(

41 FROM_HERE,

42 base::Bind(&ScreenObserverDelegate::RemoveObserverOnUIThread, this));

43 }

44

45 private:

46 friend class base::RefCountedThreadSafe<ScreenObserverDelegate>;

47

48 ~ScreenObserverDelegate() override { DCHECK(!capture_device_); }

49

50 void OnDisplayAdded(const display::Display& /new_display/) override {}

51 void OnDisplayRemoved(const display::Display& /old_display/) override {}

52 void OnDisplayMetricsChanged(const display::Display& display,

53 uint32_t metrics) override {

54 DCHECK(ui_task_runner_->BelongsToCurrentThread());

55 if (!(metrics & DISPLAY_METRIC_ROTATION))

56 return;

57 SendDisplayRotation(display);

58 }

59

60 void AddObserverOnUIThread() {

61 DCHECK(ui_task_runner_->BelongsToCurrentThread());

62 display::Screen* screen = display::Screen::GetScreen();

63 if (screen) {

64 screen->AddObserver(this);

65 SendDisplayRotation(screen->GetPrimaryDisplay());

66 }

67 }

68

69 void RemoveObserverOnUIThread() {

70 DCHECK(ui_task_runner_->BelongsToCurrentThread());

71 display::Screen* screen = display::Screen::GetScreen();

72 if (screen)

73 screen->RemoveObserver(this);

74 }

75

76 // Post the screen rotation change from the UI thread to capture thread

77 void SendDisplayRotation(const display::Display& display) {

78 DCHECK(ui_task_runner_->BelongsToCurrentThread());

79 capture_task_runner_->PostTask(

80 FROM_HERE,

81 base::Bind(&ScreenObserverDelegate::SendDisplayRotationOnCaptureThread,

82 this, display));

83 }

84

85 void SendDisplayRotationOnCaptureThread(const display::Display& display) {

86 DCHECK(capture_task_runner_->BelongsToCurrentThread());

87 if (capture_device_)

88 capture_device_->SetDisplayRotation(display);

89 }

90

91 VideoCaptureDeviceChromeOS* capture_device_;

92 scoped_refptr<base::SingleThreadTaskRunner> ui_task_runner_;

93 scoped_refptr<base::SingleThreadTaskRunner> capture_task_runner_;

94 DISALLOW_IMPLICIT_CONSTRUCTORS(ScreenObserverDelegate);

95 };

96

97 VideoCaptureDeviceChromeOS::VideoCaptureDeviceChromeOS(

98 scoped_refptr<base::SingleThreadTaskRunner> ui_task_runner,

99 const Name& device_name)

100 : VideoCaptureDeviceLinux(device_name),

101 screen_observer_delegate_(

102 new ScreenObserverDelegate(this, ui_task_runner)) {

103 }

104

105 VideoCaptureDeviceChromeOS::~VideoCaptureDeviceChromeOS() {

106 screen_observer_delegate_->RemoveObserver();

107 }

108

109 void VideoCaptureDeviceChromeOS::SetDisplayRotation(

110 const display::Display& display) {

111 if (display.IsInternal())

112 SetRotation(display.rotation() * 90);

113 }

114

115 } // namespace media

OLD	NEW