Blimp: Add BlobChannel Helium messages and delegate impls.

blimp/common/logging.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 "blimp/common/logging.h"
 
 #include <iostream>
 #include <string>
 #include <vector>
 
 #include "base/format_macros.h"
 #include "base/json/string_escape.h"
 #include "base/lazy_instance.h"
 #include "base/memory/ptr_util.h"
+#include "base/strings/string_number_conversions.h"
 #include "base/strings/string_util.h"
 #include "base/strings/stringprintf.h"
+#include "blimp/common/create_blimp_message.h"
 #include "blimp/common/proto/blimp_message.pb.h"
 
 namespace blimp {
 namespace {
 
 static base::LazyInstance<BlimpMessageLogger> g_logger =
     LAZY_INSTANCE_INITIALIZER;
 
 // The AddField() suite of functions are used to convert KV pairs with
 // arbitrarily typed values into string/string KV pairs for logging.
@@ skipping 214 matching lines @@
       case TabControlMessage::kSize:
         AddField("subtype", "SIZE", output);
         AddField("size", message.tab_control().size(), output);
         break;
       default:  // unknown
         break;
     }
   }
 };
 
+// Logs fields from BLOB_CHANNEL messages.
+class BlobChannelLogExtractor : public LogExtractor {
+  void ExtractFields(const BlimpMessage& message,
+                     LogFields* output) const override {
+    switch (message.blob_channel().type_case()) {
+      case BlobChannelMessage::TypeCase::kTransferBlob:
+        AddField("subtype", "TRANSFER_BLOB", output);
+        AddField("id",
+                 base::HexEncode(
+                     message.blob_channel().transfer_blob().blob_id().data(),
+                     message.blob_channel().transfer_blob().blob_id().size()),
+                 output);
+        AddField("payload_size",
+                 message.blob_channel().transfer_blob().payload().size(),
+                 output);
+        break;
+      case BlobChannelMessage::TypeCase::TYPE_NOT_SET:  // unknown
+        break;
+    }
+  }
+};
+
 // No fields are extracted from |message|.
 class NullLogExtractor : public LogExtractor {
   void ExtractFields(const BlimpMessage& message,
                      LogFields* output) const override {}
 };
 
 }  // namespace
 
 BlimpMessageLogger::BlimpMessageLogger() {
   AddHandler("COMPOSITOR", BlimpMessage::kCompositor,
              base::WrapUnique(new CompositorLogExtractor));
   AddHandler("INPUT", BlimpMessage::kInput,
              base::WrapUnique(new InputLogExtractor));
   AddHandler("NAVIGATION", BlimpMessage::kNavigation,
              base::WrapUnique(new NavigationLogExtractor));
   AddHandler("PROTOCOL_CONTROL", BlimpMessage::kProtocolControl,
              base::WrapUnique(new ProtocolControlLogExtractor));
   AddHandler("RENDER_WIDGET", BlimpMessage::kRenderWidget,
              base::WrapUnique(new RenderWidgetLogExtractor));
   AddHandler("SETTINGS", BlimpMessage::kSettings,
              base::WrapUnique(new SettingsLogExtractor));
   AddHandler("TAB_CONTROL", BlimpMessage::kTabControl,
              base::WrapUnique(new TabControlLogExtractor));
+  AddHandler("BLOB_CHANNEL", BlimpMessage::kBlobChannel,
+             base::WrapUnique(new BlobChannelLogExtractor));
 }
 
 BlimpMessageLogger::~BlimpMessageLogger() {}
 
 void BlimpMessageLogger::AddHandler(const std::string& feature_name,
                                     BlimpMessage::FeatureCase feature_case,
                                     std::unique_ptr<LogExtractor> extractor) {
   DCHECK(extractors_.find(feature_case) == extractors_.end());
   DCHECK(!feature_name.empty());
   extractors_[feature_case] = make_pair(feature_name, std::move(extractor));
@@ skipping 30 matching lines @@
   }
   *out << ">";
 }
 
 std::ostream& operator<<(std::ostream& out, const BlimpMessage& message) {
   g_logger.Get().LogMessageToStream(message, &out);
   return out;
 }
 
 }  // namespace blimp