Add multiline braille support.

chrome/browser/extensions/api/braille_display_private/braille_display_private_apitest.cc

 // Copyright 2013 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.
 
 #ifndef USE_BRLAPI
 #error This test requires brlapi.
 #endif
 
 #include <stddef.h>
 
@@ skipping 36 matching lines @@
 // Used to make ReadKeys return an error.
 brlapi_keyCode_t kErrorKeyCode = BRLAPI_KEY_MAX;
 
 }  // namespace
 
 // Data maintained by the mock BrlapiConnection.  This data lives throughout
 // a test, while the api implementation takes ownership of the connection
 // itself.
 struct MockBrlapiConnectionData {
   bool connected;
-  size_t display_size;
+  size_t display_columns;
+  size_t display_rows;
   brlapi_error_t error;
   std::vector<std::string> written_content;
   // List of brlapi key codes.  A negative number makes the connection mock
   // return an error from ReadKey.
   std::deque<brlapi_keyCode_t> pending_keys;
   // Causes a new display to appear to appear on disconnect, that is the
   // display size doubles and the controller gets notified of a brltty
   // restart.
   bool reappear_on_disconnect;
 };
 
 class MockBrlapiConnection : public BrlapiConnection {
  public:
   explicit MockBrlapiConnection(MockBrlapiConnectionData* data)
       : data_(data) {}
   ConnectResult Connect(const OnDataReadyCallback& on_data_ready) override {
     data_->connected = true;
     on_data_ready_ = on_data_ready;
     if (!data_->pending_keys.empty()) {
       BrowserThread::PostTask(BrowserThread::IO, FROM_HERE,
                               base::Bind(&MockBrlapiConnection::NotifyDataReady,
                                         base::Unretained(this)));
     }
     return CONNECT_SUCCESS;
   }
 
   void Disconnect() override {
     data_->connected = false;
     if (data_->reappear_on_disconnect) {
-      data_->display_size *= 2;
+      data_->display_columns *= 2;
       BrowserThread::PostTask(
           BrowserThread::IO, FROM_HERE,
           base::Bind(&BrailleControllerImpl::PokeSocketDirForTesting,
                      base::Unretained(BrailleControllerImpl::GetInstance())));
     }
   }
 
   bool Connected() override { return data_->connected; }
 
   brlapi_error_t* BrlapiError() override { return &data_->error; }
 
   std::string BrlapiStrError() override {
     return data_->error.brlerrno != BRLAPI_ERROR_SUCCESS ? "Error" : "Success";
   }
 
-  bool GetDisplaySize(size_t* size) override {
-    *size = data_->display_size;
+  bool GetDisplaySize(unsigned int* columns, unsigned int* rows) override {
+    *columns = data_->display_columns;
+    *rows = data_->display_rows;
     return true;
   }
 
-  bool WriteDots(const unsigned char* cells) override {
-    std::string written(reinterpret_cast<const char*>(cells),
-                        data_->display_size);
+  bool WriteDots(const std::vector<unsigned char>& cells) override {
+    std::string written(
+        cells.begin(),
+        cells.begin() + data_->display_rows * data_->display_columns);
     data_->written_content.push_back(written);
     return true;
   }
 
   int ReadKey(brlapi_keyCode_t* key_code) override {
     if (!data_->pending_keys.empty()) {
       brlapi_keyCode_t queued_key_code = data_->pending_keys.front();
       data_->pending_keys.pop_front();
       if (queued_key_code == kErrorKeyCode) {
         data_->error.brlerrno = BRLAPI_ERROR_EOF;
@@ skipping 19 matching lines @@
 
   MockBrlapiConnectionData* data_;
   OnDataReadyCallback on_data_ready_;
 };
 
 class BrailleDisplayPrivateApiTest : public ExtensionApiTest {
  public:
   void SetUpInProcessBrowserTestFixture() override {
     ExtensionApiTest::SetUpInProcessBrowserTestFixture();
     connection_data_.connected = false;
-    connection_data_.display_size = 0;
+    connection_data_.display_rows = 0;
+    connection_data_.display_columns = 0;
     connection_data_.error.brlerrno = BRLAPI_ERROR_SUCCESS;
     connection_data_.reappear_on_disconnect = false;
     BrailleControllerImpl::GetInstance()->SetCreateBrlapiConnectionForTesting(
         base::Bind(
             &BrailleDisplayPrivateApiTest::CreateBrlapiConnection,
             base::Unretained(this)));
     DisableAccessibilityManagerBraille();
   }
 
  protected:
@@ skipping 10 matching lines @@
  private:
   std::unique_ptr<BrlapiConnection> CreateBrlapiConnection() {
     return std::unique_ptr<BrlapiConnection>(
         new MockBrlapiConnection(&connection_data_));
   }
 
   StubBrailleController stub_braille_controller_;
 };
 
 IN_PROC_BROWSER_TEST_F(BrailleDisplayPrivateApiTest, WriteDots) {
-  connection_data_.display_size = 11;
+  connection_data_.display_columns = 11;
+  connection_data_.display_rows = 1;
   ASSERT_TRUE(RunComponentExtensionTest("braille_display_private/write_dots"))
       << message_;
   ASSERT_EQ(3U, connection_data_.written_content.size());
-  const std::string expected_content(connection_data_.display_size, '\0');
+  const std::string expected_content(
+      connection_data_.display_columns * connection_data_.display_rows, '\0');
   for (size_t i = 0; i < connection_data_.written_content.size(); ++i) {
-    ASSERT_EQ(std::string(
-        connection_data_.display_size,
-        static_cast<char>(i)),
-                 connection_data_.written_content[i])
+    ASSERT_EQ(std::string(connection_data_.display_columns *
+                              connection_data_.display_rows,
+                          static_cast<char>(i)),
+              connection_data_.written_content[i])
         << "String " << i << " doesn't match";
   }
 }
 
 IN_PROC_BROWSER_TEST_F(BrailleDisplayPrivateApiTest, KeyEvents) {
-  connection_data_.display_size = 11;
+  connection_data_.display_columns = 11;
+  connection_data_.display_rows = 1;
 
   // Braille navigation commands.
   connection_data_.pending_keys.push_back(BRLAPI_KEY_TYPE_CMD |
                                           BRLAPI_KEY_CMD_LNUP);
   connection_data_.pending_keys.push_back(BRLAPI_KEY_TYPE_CMD |
                                           BRLAPI_KEY_CMD_LNDN);
   connection_data_.pending_keys.push_back(BRLAPI_KEY_TYPE_CMD |
                                           BRLAPI_KEY_CMD_FWINLT);
   connection_data_.pending_keys.push_back(BRLAPI_KEY_TYPE_CMD |
                                           BRLAPI_KEY_CMD_FWINRT);
@@ skipping 42 matching lines @@
   // Braille dot keys, all combinations including space (0).
   for (int i = 0; i < 256; ++i) {
     connection_data_.pending_keys.push_back(BRLAPI_KEY_TYPE_CMD |
                                             BRLAPI_KEY_CMD_PASSDOTS | i);
   }
 
   ASSERT_TRUE(RunComponentExtensionTest("braille_display_private/key_events"));
 }
 
 IN_PROC_BROWSER_TEST_F(BrailleDisplayPrivateApiTest, DisplayStateChanges) {
-  connection_data_.display_size = 11;
+  connection_data_.display_columns = 11;
+  connection_data_.display_rows = 1;
   connection_data_.pending_keys.push_back(kErrorKeyCode);
   connection_data_.reappear_on_disconnect = true;
   ASSERT_TRUE(RunComponentExtensionTest(
       "braille_display_private/display_state_changes"));
 }
 
 class BrailleDisplayPrivateAPIUserTest : public BrailleDisplayPrivateApiTest {
  public:
   void SetUpCommandLine(base::CommandLine* command_line) override {
     command_line->AppendSwitch(chromeos::switches::kLoginManager);
@@ skipping 97 matching lines @@
   DismissLockScreen(tester.get());
   signin_api.OnBrailleKeyEvent(key_event);
   user_api.OnBrailleKeyEvent(key_event);
   EXPECT_EQ(1, signin_delegate->GetEventCount());
   EXPECT_EQ(2, user_delegate->GetEventCount());
 }
 
 }  // namespace braille_display_private
 }  // namespace api
 }  // namespace extensions