headless: Remove iostream usage

headless/app/headless_shell.cc

 // Copyright 2016 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 <iostream>
 #include <memory>
+#include <sstream>
 #include <string>
 
 #include "base/base64.h"
 #include "base/bind.h"
 #include "base/callback.h"
 #include "base/command_line.h"
 #include "base/files/file_path.h"
 #include "base/json/json_writer.h"
 #include "base/location.h"
 #include "base/memory/ref_counted.h"
@@ skipping 219 matching lines @@
 
   void OnPageReady() {
     if (processed_page_ready_)
       return;
     processed_page_ready_ = true;
 
     if (base::CommandLine::ForCurrentProcess()->HasSwitch(switches::kDumpDom)) {
       FetchDom();
     } else if (base::CommandLine::ForCurrentProcess()->HasSwitch(
                    switches::kRepl)) {
-      std::cout
-          << "Type a Javascript expression to evaluate or \"quit\" to exit."
-          << std::endl;
+      LOG(INFO)
+          << "Type a Javascript expression to evaluate or \"quit\" to exit.";
       InputExpression();
     } else if (base::CommandLine::ForCurrentProcess()->HasSwitch(
                    switches::kScreenshot)) {
       CaptureScreenshot();
     } else {
       Shutdown();
     }
   }
 
   void FetchDom() {
     devtools_client_->GetRuntime()->Evaluate(
         "document.body.innerHTML",
         base::Bind(&HeadlessShell::OnDomFetched, weak_factory_.GetWeakPtr()));
   }
 
   void OnDomFetched(std::unique_ptr<runtime::EvaluateResult> result) {
     if (result->HasExceptionDetails()) {
       LOG(ERROR) << "Failed to evaluate document.body.innerHTML: "
                  << result->GetExceptionDetails()->GetText();
     } else {
       std::string dom;
       if (result->GetResult()->GetValue()->GetAsString(&dom)) {
-        std::cout << dom << std::endl;
+        printf("%s\n", dom.c_str());
       }
     }
     Shutdown();
   }
 
   void InputExpression() {
     // Note that a real system should read user input asynchronously, because
     // otherwise all other browser activity is suspended (e.g., page loading).
-    std::string expression;
-    std::cout << ">>> ";
-    std::getline(std::cin, expression);
-    if (std::cin.bad() || std::cin.eof() || expression == "quit") {
+    printf(">>> ");
+    std::stringstream expression;
+    while (true) {
+      char c = fgetc(stdin);
+      if (c == EOF || c == '\n') {
+        break;
+      }
+      expression << c;
+    }
+    if (expression.str() == "quit") {
       Shutdown();
       return;
     }
     devtools_client_->GetRuntime()->Evaluate(
-        expression, base::Bind(&HeadlessShell::OnExpressionResult,
-                               weak_factory_.GetWeakPtr()));
+        expression.str(), base::Bind(&HeadlessShell::OnExpressionResult,
+                                     weak_factory_.GetWeakPtr()));
   }
 
   void OnExpressionResult(std::unique_ptr<runtime::EvaluateResult> result) {
     std::unique_ptr<base::Value> value = result->Serialize();
     std::string result_json;
     base::JSONWriter::Write(*value, &result_json);
-    std::cout << result_json << std::endl;
+    printf("%s\n", result_json.c_str());
     InputExpression();
   }
 
   void CaptureScreenshot() {
     devtools_client_->GetPage()->GetExperimental()->CaptureScreenshot(
         page::CaptureScreenshotParams::Builder().Build(),
         base::Bind(&HeadlessShell::OnScreenshotCaptured,
                    weak_factory_.GetWeakPtr()));
   }
 
@@ skipping 47 matching lines @@
   }
 
   void OnScreenshotFileWritten(const base::FilePath file_name,
                                const int length,
                                const int write_result) {
     if (write_result < length) {
       // TODO(eseckler): Support recovering from partial writes.
       LOG(ERROR) << "Writing screenshot to file " << file_name.value()
                  << " was unsuccessful: " << net::ErrorToString(write_result);
     } else {
-      std::cout << "Screenshot written to file " << file_name.value() << "."
+      LOG(INFO) << "Screenshot written to file " << file_name.value() << "."
                 << std::endl;
     }
     int close_result = screenshot_file_stream_->Close(base::Bind(
         &HeadlessShell::OnScreenshotFileClosed, weak_factory_.GetWeakPtr()));
     if (close_result != net::ERR_IO_PENDING) {
       // Operation could not be started.
       OnScreenshotFileClosed(close_result);
     }
   }
 
@@ skipping 90 matching lines @@
     }
     builder.SetWindowSize(parsed_window_size);
   }
 
   return HeadlessBrowserMain(
       builder.Build(),
       base::Bind(&HeadlessShell::OnStart, base::Unretained(&shell)));
 }
 
 }  // namespace headless