Set serial connection parameters immediately on connect.

extensions/renderer/api/serial/serial_api_unittest.cc

 // Copyright 2014 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 "device/serial/serial_device_enumerator.h"
 #include "device/serial/serial_service_impl.h"
 #include "device/serial/test_serial_io_handler.h"
 #include "extensions/common/mojo/keep_alive.mojom.h"
 #include "extensions/renderer/api_test_base.h"
 #include "grit/extensions_renderer_resources.h"
@@ skipping 158 matching lines @@
 
  private:
   ~GetControlSignalsTestIoHandler() override {}
 
   DISALLOW_COPY_AND_ASSIGN(GetControlSignalsTestIoHandler);
 };
 
 class ConfigurePortTestIoHandler : public TestIoHandlerBase {
  public:
   ConfigurePortTestIoHandler() {}
-  bool ConfigurePort(
-      const device::serial::ConnectionOptions& options) override {
+  bool ConfigurePortImpl() override {
     static const device::serial::ConnectionOptions expected_options[] = {
         GenerateConnectionOptions(9600,
                                   device::serial::DATA_BITS_EIGHT,
                                   device::serial::PARITY_BIT_NO,
                                   device::serial::STOP_BITS_ONE,
                                   OPTIONAL_VALUE_FALSE),
+        GenerateConnectionOptions(57600, // set

[Ken Rockot(use gerrit already), 2015/01/28 21:25:34]

nit: two spaces before //

+                                  device::serial::DATA_BITS_EIGHT,
+                                  device::serial::PARITY_BIT_NO,
+                                  device::serial::STOP_BITS_ONE,
+                                  OPTIONAL_VALUE_FALSE),
         GenerateConnectionOptions(57600,
-                                  device::serial::DATA_BITS_NONE,
-                                  device::serial::PARITY_BIT_NONE,
-                                  device::serial::STOP_BITS_NONE,
-                                  OPTIONAL_VALUE_UNSET),
-        GenerateConnectionOptions(0,
-                                  device::serial::DATA_BITS_SEVEN,
-                                  device::serial::PARITY_BIT_NONE,
-                                  device::serial::STOP_BITS_NONE,
-                                  OPTIONAL_VALUE_UNSET),
-        GenerateConnectionOptions(0,
+                                  device::serial::DATA_BITS_SEVEN,  // set

[Ken Rockot(use gerrit already), 2015/01/28 19:22:10]

what is all this "  // set" notation

[Reilly Grant (use Gerrit), 2015/01/28 21:00:09]

In the original test because the unmodified options where not passed to
ConfigurePort they would have their default values. Now that they have their
previous values I thought it would improve readability to make it clear which
value was actually changed in each test case.

+                                  device::serial::PARITY_BIT_NO,
+                                  device::serial::STOP_BITS_ONE,
+                                  OPTIONAL_VALUE_FALSE),
+        GenerateConnectionOptions(57600,
+                                  device::serial::DATA_BITS_EIGHT,  // set
+                                  device::serial::PARITY_BIT_NO,
+                                  device::serial::STOP_BITS_ONE,
+                                  OPTIONAL_VALUE_FALSE),
+        GenerateConnectionOptions(57600,
                                   device::serial::DATA_BITS_EIGHT,
-                                  device::serial::PARITY_BIT_NONE,
-                                  device::serial::STOP_BITS_NONE,
-                                  OPTIONAL_VALUE_UNSET),
-        GenerateConnectionOptions(0,
-                                  device::serial::DATA_BITS_NONE,
-                                  device::serial::PARITY_BIT_NO,
-                                  device::serial::STOP_BITS_NONE,
-                                  OPTIONAL_VALUE_UNSET),
-        GenerateConnectionOptions(0,
-                                  device::serial::DATA_BITS_NONE,
-                                  device::serial::PARITY_BIT_ODD,
-                                  device::serial::STOP_BITS_NONE,
-                                  OPTIONAL_VALUE_UNSET),
-        GenerateConnectionOptions(0,
-                                  device::serial::DATA_BITS_NONE,
+                                  device::serial::PARITY_BIT_NO,  // set
+                                  device::serial::STOP_BITS_ONE,
+                                  OPTIONAL_VALUE_FALSE),
+        GenerateConnectionOptions(57600,
+                                  device::serial::DATA_BITS_EIGHT,
+                                  device::serial::PARITY_BIT_ODD,  // set
+                                  device::serial::STOP_BITS_ONE,
+                                  OPTIONAL_VALUE_FALSE),
+        GenerateConnectionOptions(57600,
+                                  device::serial::DATA_BITS_EIGHT,
+                                  device::serial::PARITY_BIT_EVEN,  // set
+                                  device::serial::STOP_BITS_ONE,
+                                  OPTIONAL_VALUE_FALSE),
+        GenerateConnectionOptions(57600,
+                                  device::serial::DATA_BITS_EIGHT,
                                   device::serial::PARITY_BIT_EVEN,
-                                  device::serial::STOP_BITS_NONE,
-                                  OPTIONAL_VALUE_UNSET),
-        GenerateConnectionOptions(0,
-                                  device::serial::DATA_BITS_NONE,
-                                  device::serial::PARITY_BIT_NONE,
-                                  device::serial::STOP_BITS_ONE,
-                                  OPTIONAL_VALUE_UNSET),
-        GenerateConnectionOptions(0,
-                                  device::serial::DATA_BITS_NONE,
-                                  device::serial::PARITY_BIT_NONE,
+                                  device::serial::STOP_BITS_ONE,  // set
+                                  OPTIONAL_VALUE_FALSE),
+        GenerateConnectionOptions(57600,
+                                  device::serial::DATA_BITS_EIGHT,
+                                  device::serial::PARITY_BIT_EVEN,
+                                  device::serial::STOP_BITS_TWO,  // set
+                                  OPTIONAL_VALUE_FALSE),
+        GenerateConnectionOptions(57600,
+                                  device::serial::DATA_BITS_EIGHT,
+                                  device::serial::PARITY_BIT_EVEN,
                                   device::serial::STOP_BITS_TWO,
-                                  OPTIONAL_VALUE_UNSET),
-        GenerateConnectionOptions(0,
-                                  device::serial::DATA_BITS_NONE,
-                                  device::serial::PARITY_BIT_NONE,
-                                  device::serial::STOP_BITS_NONE,
-                                  OPTIONAL_VALUE_FALSE),
-        GenerateConnectionOptions(0,
-                                  device::serial::DATA_BITS_NONE,
-                                  device::serial::PARITY_BIT_NONE,
-                                  device::serial::STOP_BITS_NONE,
-                                  OPTIONAL_VALUE_TRUE),
+                                  OPTIONAL_VALUE_FALSE),  // set
+        GenerateConnectionOptions(57600,
+                                  device::serial::DATA_BITS_EIGHT,
+                                  device::serial::PARITY_BIT_EVEN,
+                                  device::serial::STOP_BITS_TWO,
+                                  OPTIONAL_VALUE_TRUE),  // set
     };
-    if (num_calls() >= arraysize(expected_options))
+
+    if (!TestIoHandlerBase::ConfigurePortImpl()) {
       return false;
+    }
 
-    EXPECT_EQ(expected_options[num_calls()].bitrate, options.bitrate);
-    EXPECT_EQ(expected_options[num_calls()].data_bits, options.data_bits);
-    EXPECT_EQ(expected_options[num_calls()].parity_bit, options.parity_bit);
-    EXPECT_EQ(expected_options[num_calls()].stop_bits, options.stop_bits);
+    if (num_calls() >= arraysize(expected_options)) {
+      return false;
+    }
+
+    EXPECT_EQ(expected_options[num_calls()].bitrate, options().bitrate);
+    EXPECT_EQ(expected_options[num_calls()].data_bits, options().data_bits);
+    EXPECT_EQ(expected_options[num_calls()].parity_bit, options().parity_bit);
+    EXPECT_EQ(expected_options[num_calls()].stop_bits, options().stop_bits);
     EXPECT_EQ(expected_options[num_calls()].has_cts_flow_control,
-              options.has_cts_flow_control);
+              options().has_cts_flow_control);
     EXPECT_EQ(expected_options[num_calls()].cts_flow_control,
-              options.cts_flow_control);
+              options().cts_flow_control);
     record_call();
-    return TestSerialIoHandler::ConfigurePort(options);
+    return true;
   }
 
  private:
   ~ConfigurePortTestIoHandler() override {}
 
   DISALLOW_COPY_AND_ASSIGN(ConfigurePortTestIoHandler);
 };
 
 class FlushTestIoHandler : public TestIoHandlerBase {
  public:
   FlushTestIoHandler() {}
 
   bool Flush() const override {
     record_call();
     return true;
   }
 
  private:
   ~FlushTestIoHandler() override {}
 
   DISALLOW_COPY_AND_ASSIGN(FlushTestIoHandler);
 };
 
 class FailToConnectTestIoHandler : public TestIoHandlerBase {
  public:
   FailToConnectTestIoHandler() {}
   void Open(const std::string& port,
+            const device::serial::ConnectionOptions& options,
             const OpenCompleteCallback& callback) override {
     callback.Run(false);
     return;
   }
 
  private:
   ~FailToConnectTestIoHandler() override {}
 
   DISALLOW_COPY_AND_ASSIGN(FailToConnectTestIoHandler);
 };
@@ skipping 337 matching lines @@
 
 TEST_F(SerialApiTest, SetPausedUnknownConnectionId) {
   RunTest("serial_unittest.js", "testSetPausedUnknownConnectionId");
 }
 
 TEST_F(SerialApiTest, SendUnknownConnectionId) {
   RunTest("serial_unittest.js", "testSendUnknownConnectionId");
 }
 
 }  // namespace extensions