content/browser/renderer_host/clipboard_message_filter_unittest.cc - Issue 740003003: Revert of Rewrite clipboard write IPC handling to be easier to understand.

Side by Side Diff: content/browser/renderer_host/clipboard_message_filter_unittest.cc

Issue 740003003: Revert of Rewrite clipboard write IPC handling to be easier to understand. (Closed) Base URL: https://chromium.googlesource.com/chromium/src.git@master

Patch Set: Created 6 years, 1 month 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

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 "content/browser/renderer_host/clipboard_message_filter.h"

6

7 #include <string.h>

8

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

10 #include "base/process/process_handle.h"

11 #include "base/run_loop.h"

12 #include "content/public/test/test_browser_thread_bundle.h"

13 #include "testing/gtest/include/gtest/gtest.h"

14 #include "third_party/skia/include/core/SkBitmap.h"

15 #include "ui/base/test/test_clipboard.h"

16 #include "ui/gfx/size.h"

17

18 namespace content {

19

20 class ClipboardMessageFilterTest : public ::testing::Test {

21 protected:

22 ClipboardMessageFilterTest()

23 : filter_(new ClipboardMessageFilter),

24 clipboard_(ui::TestClipboard::CreateForCurrentThread()) {

25 filter_->set_peer_pid_for_testing(base::GetCurrentProcId());

26 }

27

28 virtual ~ClipboardMessageFilterTest() override {

29 ui::Clipboard::DestroyClipboardForCurrentThread();

30 }

31

32 scoped_ptr<base::SharedMemory> CreateAndMapReadOnlySharedMemory(size_t size) {

33 scoped_ptr<base::SharedMemory> m = CreateReadOnlySharedMemory(size);

34 if (!m->Map(size))

35 return nullptr;

36 return m;

37 }

38

39 scoped_ptr<base::SharedMemory> CreateReadOnlySharedMemory(size_t size) {

40 scoped_ptr<base::SharedMemory> m(new base::SharedMemory());

41 base::SharedMemoryCreateOptions options;

42 options.size = size;

43 options.share_read_only = true;

44 if (!m->Create(options))

45 return nullptr;

46 return m;

47 }

48

49 void CallWriteImage(const gfx::Size& size,

50 base::SharedMemory* shared_memory) {

51 base::SharedMemoryHandle handle;

52 ASSERT_TRUE(shared_memory->GiveReadOnlyToProcess(

53 base::GetCurrentProcessHandle(), &handle));

54 CallWriteImageDirectly(size, handle);

55 }

56

57 // Prefer to use CallWriteImage() in tests.

58 void CallWriteImageDirectly(const gfx::Size& size,

59 base::SharedMemoryHandle handle) {

60 filter_->OnWriteImage(ui::CLIPBOARD_TYPE_COPY_PASTE, size, handle);

61 }

62

63 void CallCommitWrite() {

64 filter_->OnCommitWrite(ui::CLIPBOARD_TYPE_COPY_PASTE);

65 base::RunLoop().RunUntilIdle();

66 }

67

68 ui::Clipboard* clipboard() { return clipboard_; }

69

70 private:

71 const TestBrowserThreadBundle thread_bundle_;

72 const scoped_refptr<ClipboardMessageFilter> filter_;

73 ui::Clipboard* const clipboard_;

74 };

75

76 // Test that it actually works.

77 TEST_F(ClipboardMessageFilterTest, SimpleImage) {

78 static const uint32_t bitmap_data[] = {

79 0x33333333, 0xdddddddd, 0xeeeeeeee, 0x00000000,

80 0x88888888, 0x66666666, 0x55555555, 0xbbbbbbbb,

81 0x44444444, 0xaaaaaaaa, 0x99999999, 0x77777777,

82 0xffffffff, 0x11111111, 0x22222222, 0xcccccccc,

83 };

84

85 scoped_ptr<base::SharedMemory> shared_memory =

86 CreateAndMapReadOnlySharedMemory(sizeof(bitmap_data));

87 memcpy(shared_memory->memory(), bitmap_data, sizeof(bitmap_data));

88

89 CallWriteImage(gfx::Size(4, 4), shared_memory.get());

90 uint64_t sequence_number =

91 clipboard()->GetSequenceNumber(ui::CLIPBOARD_TYPE_COPY_PASTE);

92 CallCommitWrite();

93

94 EXPECT_NE(sequence_number,

95 clipboard()->GetSequenceNumber(ui::CLIPBOARD_TYPE_COPY_PASTE));

96 EXPECT_FALSE(clipboard()->IsFormatAvailable(

97 ui::Clipboard::GetPlainTextFormatType(), ui::CLIPBOARD_TYPE_COPY_PASTE));

98 EXPECT_TRUE(clipboard()->IsFormatAvailable(

99 ui::Clipboard::GetBitmapFormatType(), ui::CLIPBOARD_TYPE_COPY_PASTE));

100

101 SkBitmap actual = clipboard()->ReadImage(ui::CLIPBOARD_TYPE_COPY_PASTE);

102 SkAutoLockPixels locked(actual);

103 EXPECT_EQ(sizeof(bitmap_data), actual.getSize());

104 EXPECT_EQ(0,

105 memcmp(bitmap_data, actual.getAddr32(0, 0), sizeof(bitmap_data)));

106 }

107

108 // Test with a size that would overflow a naive 32-bit row bytes calculation.

109 TEST_F(ClipboardMessageFilterTest, ImageSizeOverflows32BitRowBytes) {

110 scoped_ptr<base::SharedMemory> shared_memory =

111 CreateReadOnlySharedMemory(0x20000000);

112

113 CallWriteImage(gfx::Size(0x20000000, 1), shared_memory.get());

114 uint64_t sequence_number =

115 clipboard()->GetSequenceNumber(ui::CLIPBOARD_TYPE_COPY_PASTE);

116 CallCommitWrite();

117

118 EXPECT_EQ(sequence_number,

119 clipboard()->GetSequenceNumber(ui::CLIPBOARD_TYPE_COPY_PASTE));

120 }

121

122 TEST_F(ClipboardMessageFilterTest, InvalidSharedMemoryHandle) {

123 CallWriteImageDirectly(gfx::Size(5, 5), base::SharedMemory::NULLHandle());

124 uint64_t sequence_number =

125 clipboard()->GetSequenceNumber(ui::CLIPBOARD_TYPE_COPY_PASTE);

126 CallCommitWrite();

127

128 EXPECT_EQ(sequence_number,

129 clipboard()->GetSequenceNumber(ui::CLIPBOARD_TYPE_COPY_PASTE));

130 }

131

132 } // namespace content

OLD	NEW

« no previous file with comments | « content/browser/renderer_host/clipboard_message_filter.cc ('k') | content/common/clipboard_messages.h » ('j') | no next file with comments »