[DevTools] Filter any messages from previous sessions in DevToolsAgentHostImpl

content/browser/devtools/protocol/input_handler.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 "content/browser/devtools/protocol/input_handler.h"
 
 #include "base/message_loop/message_loop.h"
 #include "base/strings/stringprintf.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/trace_event/trace_event.h"
@@ skipping 288 matching lines @@
     return Response::ServerError("Could not connect to view");
 
   if (event->type == blink::WebInputEvent::MouseWheel)
     host_->ForwardWheelEvent(wheel_event);
   else
     host_->ForwardMouseEvent(mouse_event);
   return Response::OK();
 }
 
 Response InputHandler::SynthesizePinchGesture(
+    int session_id,
     DevToolsCommandId command_id,
     int x,
     int y,
     double scale_factor,
     const int* relative_speed,
     const std::string* gesture_source_type) {
   if (!host_)
     return Response::ServerError("Could not connect to view");
 
   SyntheticPinchGestureParams gesture_params;
   const int kDefaultRelativeSpeed = 800;
 
   gesture_params.scale_factor = scale_factor;
   gesture_params.anchor = CssPixelsToPointF(x, y, page_scale_factor_);
   gesture_params.relative_pointer_speed_in_pixels_s =
       relative_speed ? *relative_speed : kDefaultRelativeSpeed;
 
   if (!StringToGestureSourceType(
       gesture_source_type ? *gesture_source_type : kGestureSourceTypeDefault,
       gesture_params.gesture_source_type)) {
     return Response::InvalidParams("gestureSourceType");
   }
 
   host_->QueueSyntheticGesture(
       SyntheticGesture::Create(gesture_params),
       base::Bind(&InputHandler::SendSynthesizePinchGestureResponse,
-                 weak_factory_.GetWeakPtr(), command_id));
+                 weak_factory_.GetWeakPtr(), session_id, command_id));
 
   return Response::OK();
 }
 
 Response InputHandler::SynthesizeScrollGesture(
+    int session_id,
     DevToolsCommandId command_id,
     int x,
     int y,
     const int* x_distance,
     const int* y_distance,
     const int* x_overscroll,
     const int* y_overscroll,
     const bool* prevent_fling,
     const int* speed,
     const std::string* gesture_source_type,
@@ skipping 27 matching lines @@
   if (!StringToGestureSourceType(
       gesture_source_type ? *gesture_source_type : kGestureSourceTypeDefault,
       gesture_params.gesture_source_type)) {
     return Response::InvalidParams("gestureSourceType");
   }
 
   SynthesizeRepeatingScroll(
       gesture_params, repeat_count ? *repeat_count : 0,
       base::TimeDelta::FromMilliseconds(repeat_delay_ms ? *repeat_delay_ms
                                                         : 250),
-      interaction_marker_name ? *interaction_marker_name : "", command_id);
+      interaction_marker_name ? *interaction_marker_name : "", session_id,
+      command_id);
 
   return Response::OK();
 }
 
 void InputHandler::SynthesizeRepeatingScroll(
     SyntheticSmoothScrollGestureParams gesture_params,
     int repeat_count,
     base::TimeDelta repeat_delay,
     std::string interaction_marker_name,
+    int session_id,
     DevToolsCommandId command_id) {
   if (!interaction_marker_name.empty()) {
     // TODO(alexclarke): Can we move this elsewhere? It doesn't really fit here.
     TRACE_EVENT_COPY_ASYNC_BEGIN0("benchmark",
                                   interaction_marker_name.c_str(), command_id);
   }
 
   host_->QueueSyntheticGesture(
       SyntheticGesture::Create(gesture_params),
       base::Bind(&InputHandler::OnScrollFinished, weak_factory_.GetWeakPtr(),
                  gesture_params, repeat_count, repeat_delay,
-                 interaction_marker_name, command_id));
+                 interaction_marker_name, session_id, command_id));
 }
 
 void InputHandler::OnScrollFinished(
     SyntheticSmoothScrollGestureParams gesture_params,
     int repeat_count,
     base::TimeDelta repeat_delay,
     std::string interaction_marker_name,
+    int session_id,
     DevToolsCommandId command_id,
     SyntheticGesture::Result result) {
   if (!interaction_marker_name.empty()) {
     TRACE_EVENT_COPY_ASYNC_END0("benchmark",
                                 interaction_marker_name.c_str(), command_id);
   }
 
   if (repeat_count > 0) {
     base::MessageLoop::current()->task_runner()->PostDelayedTask(
-        FROM_HERE,
-        base::Bind(&InputHandler::SynthesizeRepeatingScroll,
-                   weak_factory_.GetWeakPtr(), gesture_params, repeat_count - 1,
-                   repeat_delay, interaction_marker_name, command_id),
+        FROM_HERE, base::Bind(&InputHandler::SynthesizeRepeatingScroll,
+                              weak_factory_.GetWeakPtr(), gesture_params,
+                              repeat_count - 1, repeat_delay,
+                              interaction_marker_name, session_id, command_id),
         repeat_delay);
   } else {
-    SendSynthesizeScrollGestureResponse(command_id, result);
+    SendSynthesizeScrollGestureResponse(session_id, command_id, result);
   }
 }
 
 Response InputHandler::SynthesizeTapGesture(
+    int session_id,
     DevToolsCommandId command_id,
     int x,
     int y,
     const int* duration,
     const int* tap_count,
     const std::string* gesture_source_type) {
   if (!host_)
     return Response::ServerError("Could not connect to view");
 
   SyntheticTapGestureParams gesture_params;
@@ skipping 12 matching lines @@
   if (!tap_count)
     tap_count = &kDefaultTapCount;
 
   for (int i = 0; i < *tap_count; i++) {
     // If we're doing more than one tap, don't send the response to the client
     // until we've completed the last tap.
     bool is_last_tap = i == *tap_count - 1;
     host_->QueueSyntheticGesture(
         SyntheticGesture::Create(gesture_params),
         base::Bind(&InputHandler::SendSynthesizeTapGestureResponse,
-                   weak_factory_.GetWeakPtr(), command_id, is_last_tap));
+                   weak_factory_.GetWeakPtr(), session_id, command_id,
+                   is_last_tap));
   }
 
   return Response::OK();
 }
 
 void InputHandler::SendSynthesizePinchGestureResponse(
+    int session_id,
     DevToolsCommandId command_id,
     SyntheticGesture::Result result) {
+  // todo: session_id
   if (result == SyntheticGesture::Result::GESTURE_FINISHED) {
     client_->SendSynthesizePinchGestureResponse(
-        command_id, SynthesizePinchGestureResponse::Create());
+        session_id, command_id, SynthesizePinchGestureResponse::Create());
   } else {
-    client_->SendError(command_id,
+    client_->SendError(session_id, command_id,
                        Response::InternalError(base::StringPrintf(
                            "Synthetic pinch failed, result was %d", result)));
   }
 }
 
 void InputHandler::SendSynthesizeScrollGestureResponse(
+    int session_id,
     DevToolsCommandId command_id,
     SyntheticGesture::Result result) {
   if (result == SyntheticGesture::Result::GESTURE_FINISHED) {
     client_->SendSynthesizeScrollGestureResponse(
-        command_id, SynthesizeScrollGestureResponse::Create());
+        session_id, command_id, SynthesizeScrollGestureResponse::Create());
   } else {
-    client_->SendError(command_id,
+    client_->SendError(session_id, command_id,
                        Response::InternalError(base::StringPrintf(
                            "Synthetic scroll failed, result was %d", result)));
   }
 }
 
 void InputHandler::SendSynthesizeTapGestureResponse(
+    int session_id,
     DevToolsCommandId command_id,
     bool send_success,
     SyntheticGesture::Result result) {
   if (result == SyntheticGesture::Result::GESTURE_FINISHED) {
     if (send_success) {
       client_->SendSynthesizeTapGestureResponse(
-          command_id, SynthesizeTapGestureResponse::Create());
+          session_id, command_id, SynthesizeTapGestureResponse::Create());
     }
   } else {
-    client_->SendError(command_id,
+    client_->SendError(session_id, command_id,
                        Response::InternalError(base::StringPrintf(
                            "Synthetic tap failed, result was %d", result)));
   }
 }
 
 }  // namespace input
 }  // namespace devtools
 }  // namespace content