SingleLogSource reads whole lines whenever possible

chrome/browser/chromeos/system_logs/single_log_source_unittest.cc

 // Copyright 2017 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 "chrome/browser/chromeos/system_logs/single_log_source.h"
 
 #include <string>
 
 #include "base/bind.h"
 #include "base/files/file_path.h"
@@ skipping 45 matching lines @@
     source_->log_file_dir_path_ = log_dir_.GetPath();
     log_file_path_ = source_->log_file_dir_path_.Append(source_->source_name());
     ASSERT_TRUE(base::PathExists(log_file_path_)) << log_file_path_.value();
   }
 
   // Writes/appends (respectively) a string |input| to file indicated by
   // |relative_path| under |log_dir_|.
   bool WriteFile(const base::FilePath& relative_path,
                  const std::string& input) {
     return base::WriteFile(log_dir_.GetPath().Append(relative_path),
-                           input.data(), input.size());
+                           input.data(),
+                           input.size()) == static_cast<int>(input.size());
   }
   bool AppendToFile(const base::FilePath& relative_path,
                     const std::string& input) {
     return base::AppendToFile(log_dir_.GetPath().Append(relative_path),
                               input.data(), input.size());
   }
 
   // Calls source_.Fetch() to start a logs fetch operation. Passes in
   // OnFileRead() as a callback. Runs until Fetch() has completed.
   void FetchFromSource() {
@@ skipping 153 matching lines @@
   EXPECT_EQ(2, num_callback_calls());
   EXPECT_EQ("", latest_response());
 
   EXPECT_TRUE(AppendToFile(base::FilePath("messages"), "hijk\n"));
   FetchFromSource();
 
   EXPECT_EQ(3, num_callback_calls());
   // All the previously written text should be read this time.
   EXPECT_EQ("0123456789abcdefghijk\n", latest_response());
 
-  // Partial whole-line reads are not supported. The last byte of the read must
-  // be a new line.
+  // Check ability to read whole lines while leaving the remainder for later.
   EXPECT_TRUE(AppendToFile(base::FilePath("messages"), "Hello world\n"));
   EXPECT_TRUE(AppendToFile(base::FilePath("messages"), "Goodbye world"));
   FetchFromSource();
 
   EXPECT_EQ(4, num_callback_calls());
-  EXPECT_EQ("", latest_response());
+  EXPECT_EQ("Hello world\n", latest_response());
 
   EXPECT_TRUE(AppendToFile(base::FilePath("messages"), "\n"));
   FetchFromSource();
 
   EXPECT_EQ(5, num_callback_calls());
-  EXPECT_EQ("Hello world\nGoodbye world\n", latest_response());
+  EXPECT_EQ("Goodbye world\n", latest_response());
 }
 
 TEST_F(SingleLogSourceTest, Anonymize) {
   InitializeSource(SingleLogSource::SupportedSource::kUiLatest);
 
   EXPECT_TRUE(AppendToFile(base::FilePath("ui/ui.LATEST"),
                            "My MAC address is: 11:22:33:44:55:66\n"));
   FetchFromSource();
 
   EXPECT_EQ(1, num_callback_calls());
   EXPECT_EQ("My MAC address is: 11:22:33:00:00:01\n", latest_response());
 
   // Suppose the write operation is not atomic, and the MAC address is written
   // across two separate writes.
   EXPECT_TRUE(AppendToFile(base::FilePath("ui/ui.LATEST"),
                            "Your MAC address is: AB:88:C"));
   FetchFromSource();
 
   EXPECT_EQ(2, num_callback_calls());
   EXPECT_EQ("", latest_response());
 
   EXPECT_TRUE(AppendToFile(base::FilePath("ui/ui.LATEST"), "D:99:EF:77\n"));
   FetchFromSource();
 
   EXPECT_EQ(3, num_callback_calls());
   EXPECT_EQ("Your MAC address is: ab:88:cd:00:00:02\n", latest_response());
 }
 
 }  // namespace system_logs