Snapshot of all changes to get jumbo in blink and content.

content/browser/devtools/devtools_io_context.cc

 // Copyright 2015 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 "content/browser/devtools/devtools_io_context.h"
 
 #include "base/files/file.h"
 #include "base/files/file_util.h"
 #include "base/sequenced_task_runner.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_util.h"
 #include "base/task_scheduler/post_task.h"
 #include "base/third_party/icu/icu_utf.h"
 #include "base/threading/thread_restrictions.h"
 #include "content/public/browser/browser_thread.h"
 
 namespace content {
 
 namespace {
 unsigned s_last_stream_handle = 0;
 }
 
-using Stream = DevToolsIOContext::Stream;
-
-Stream::Stream(base::SequencedTaskRunner* task_runner)
+DevToolsIOContext::Stream::Stream(base::SequencedTaskRunner* task_runner)
     : base::RefCountedDeleteOnSequence<Stream>(task_runner),
       handle_(base::UintToString(++s_last_stream_handle)),
       task_runner_(task_runner),
       had_errors_(false),
       last_read_pos_(0) {}
 
-Stream::~Stream() {
+DevToolsIOContext::Stream::~Stream() {
   DCHECK(task_runner_->RunsTasksInCurrentSequence());
 }
 
-bool Stream::InitOnFileSequenceIfNeeded() {
+bool DevToolsIOContext::Stream::InitOnFileSequenceIfNeeded() {
   DCHECK(task_runner_->RunsTasksInCurrentSequence());
   base::ThreadRestrictions::AssertIOAllowed();
   if (had_errors_)
     return false;
   if (file_.IsValid())
     return true;
   base::FilePath temp_path;
   if (!base::CreateTemporaryFile(&temp_path)) {
     LOG(ERROR) << "Failed to create temporary file";
     had_errors_ = true;
     return false;
   }
   const unsigned flags = base::File::FLAG_OPEN_TRUNCATED |
                          base::File::FLAG_WRITE | base::File::FLAG_READ |
                          base::File::FLAG_DELETE_ON_CLOSE;
   file_.Initialize(temp_path, flags);
   if (!file_.IsValid()) {
     LOG(ERROR) << "Failed to open temporary file: " << temp_path.value()
         << ", " << base::File::ErrorToString(file_.error_details());
     had_errors_ = true;
     DeleteFile(temp_path, false);
     return false;
   }
   return true;
 }
 
-void Stream::Read(off_t position, size_t max_size, ReadCallback callback) {
+void DevToolsIOContext::Stream::Read(off_t position, size_t max_size, ReadCallback callback) {
   task_runner_->PostTask(
       FROM_HERE, base::BindOnce(&Stream::ReadOnFileSequence, this, position,
                                 max_size, std::move(callback)));
 }
 
-void Stream::Append(std::unique_ptr<std::string> data) {
+void DevToolsIOContext::Stream::Append(std::unique_ptr<std::string> data) {
   task_runner_->PostTask(
       FROM_HERE,
       base::BindOnce(&Stream::AppendOnFileSequence, this, std::move(data)));
 }
 
-void Stream::ReadOnFileSequence(off_t position,
+void DevToolsIOContext::Stream::ReadOnFileSequence(off_t position,
                                 size_t max_size,
                                 ReadCallback callback) {
   DCHECK(task_runner_->RunsTasksInCurrentSequence());
   Status status = StatusFailure;
   std::unique_ptr<std::string> data;
 
   if (file_.IsValid()) {
     std::string buffer;
     buffer.resize(max_size);
     if (position < 0)
@@ skipping 15 matching lines @@
       data.reset(new std::string(std::move(buffer)));
       status = size_got ? StatusSuccess : StatusEOF;
       last_read_pos_ = position + size_got;
     }
   }
   BrowserThread::PostTask(
       BrowserThread::UI, FROM_HERE,
       base::BindOnce(std::move(callback), std::move(data), status));
 }
 
-void Stream::AppendOnFileSequence(std::unique_ptr<std::string> data) {
+void DevToolsIOContext::Stream::AppendOnFileSequence(std::unique_ptr<std::string> data) {
   if (!InitOnFileSequenceIfNeeded())
     return;
   int size_written = file_.WriteAtCurrentPos(&*data->begin(), data->length());
   if (size_written != static_cast<int>(data->length())) {
     LOG(ERROR) << "Failed to write temporary file";
     had_errors_ = true;
     file_.Close();
   }
 }
 
 DevToolsIOContext::DevToolsIOContext() = default;
 
 DevToolsIOContext::~DevToolsIOContext() = default;
 
-scoped_refptr<Stream> DevToolsIOContext::CreateTempFileBackedStream() {
+scoped_refptr<DevToolsIOContext::Stream> DevToolsIOContext::CreateTempFileBackedStream() {
   if (!task_runner_) {
     task_runner_ = base::CreateSequencedTaskRunnerWithTraits(
         {base::MayBlock(), base::TaskPriority::BACKGROUND});
   }
-  scoped_refptr<Stream> result = new Stream(task_runner_.get());
+  scoped_refptr<DevToolsIOContext::Stream> result = new DevToolsIOContext::Stream(task_runner_.get());
   bool inserted =
       streams_.insert(std::make_pair(result->handle(), result)).second;
   DCHECK(inserted);
   return result;
 }
 
-scoped_refptr<Stream>
+scoped_refptr<DevToolsIOContext::Stream>
     DevToolsIOContext::GetByHandle(const std::string& handle) {
   StreamsMap::const_iterator it = streams_.find(handle);
   return it == streams_.end() ? scoped_refptr<Stream>() : it->second;
 }
 
 bool DevToolsIOContext::Close(const std::string& handle) {
   return streams_.erase(handle) == 1;
 }
 
 void DevToolsIOContext::DiscardAllStreams() {
   return streams_.clear();
 }
 
 }  // namespace content