diff --git a/components/devtools/lib.rs b/components/devtools/lib.rs
index b8768810bef..eb3aa80dbf9 100644
--- a/components/devtools/lib.rs
+++ b/components/devtools/lib.rs
@@ -37,13 +37,14 @@ use crate::actors::browsing_context::BrowsingContextActor;
 use crate::actors::console::{ConsoleActor, Root};
 use crate::actors::device::DeviceActor;
 use crate::actors::framerate::FramerateActor;
-use crate::actors::network_event::{EventActor, NetworkEventActor, ResponseStartMsg};
+use crate::actors::network_event::NetworkEventActor;
 use crate::actors::performance::PerformanceActor;
 use crate::actors::preference::PreferenceActor;
 use crate::actors::process::ProcessActor;
 use crate::actors::root::RootActor;
 use crate::actors::thread::ThreadActor;
 use crate::actors::worker::{WorkerActor, WorkerType};
+use crate::network_handler::handle_network_event;
 use crate::protocol::JsonPacketStream;
 
 mod actor;
@@ -69,6 +70,7 @@ mod actors {
     pub mod watcher;
     pub mod worker;
 }
+mod network_handler;
 mod protocol;
 
 #[derive(Clone, Debug, Eq, Hash, PartialEq)]
@@ -77,45 +79,6 @@ enum UniqueId {
     Worker(WorkerId),
 }
 
-#[derive(Serialize)]
-#[serde(rename_all = "camelCase")]
-struct NetworkEventMsg {
-    from: String,
-    #[serde(rename = "type")]
-    type_: String,
-    event_actor: EventActor,
-}
-
-#[derive(Serialize)]
-#[serde(rename_all = "camelCase")]
-struct NetworkEventUpdateMsg {
-    from: String,
-    #[serde(rename = "type")]
-    type_: String,
-    update_type: String,
-}
-
-#[derive(Serialize)]
-#[serde(rename_all = "camelCase")]
-struct EventTimingsUpdateMsg {
-    total_time: u64,
-}
-
-#[derive(Serialize)]
-struct SecurityInfoUpdateMsg {
-    state: String,
-}
-
-#[derive(Serialize)]
-#[serde(rename_all = "camelCase")]
-struct ResponseStartUpdateMsg {
-    from: String,
-    #[serde(rename = "type")]
-    type_: String,
-    update_type: String,
-    response: ResponseStartMsg,
-}
-
 #[derive(Serialize)]
 pub struct EmptyReplyMsg {
     pub from: String,
@@ -487,7 +450,7 @@ impl DevtoolsInstance {
 
     fn handle_network_event(
         &mut self,
-        mut connections: Vec<TcpStream>,
+        connections: Vec<TcpStream>,
         pipeline_id: PipelineId,
         request_id: String,
         network_event: NetworkEvent,
@@ -497,109 +460,14 @@ impl DevtoolsInstance {
             None => return,
         };
         let netevent_actor_name = self.find_network_event_actor(request_id);
-        let mut actors = self.actors.lock().unwrap();
-        let actor = actors.find_mut::<NetworkEventActor>(&netevent_actor_name);
 
-        match network_event {
-            NetworkEvent::HttpRequest(httprequest) => {
-                // Store the request information in the actor
-                actor.add_request(httprequest);
-
-                // Send a networkEvent message to the client
-                let msg = NetworkEventMsg {
-                    from: console_actor_name,
-                    type_: "networkEvent".to_owned(),
-                    event_actor: actor.event_actor(),
-                };
-                for stream in &mut connections {
-                    let _ = stream.write_json_packet(&msg);
-                }
-            },
-            NetworkEvent::HttpResponse(httpresponse) => {
-                // Store the response information in the actor
-                actor.add_response(httpresponse);
-
-                let msg = NetworkEventUpdateMsg {
-                    from: netevent_actor_name.clone(),
-                    type_: "networkEventUpdate".to_owned(),
-                    update_type: "requestHeaders".to_owned(),
-                };
-                for stream in &mut connections {
-                    let _ = stream.write_merged_json_packet(&msg, &actor.request_headers());
-                }
-
-                let msg = NetworkEventUpdateMsg {
-                    from: netevent_actor_name.clone(),
-                    type_: "networkEventUpdate".to_owned(),
-                    update_type: "requestCookies".to_owned(),
-                };
-                for stream in &mut connections {
-                    let _ = stream.write_merged_json_packet(&msg, &actor.request_cookies());
-                }
-
-                // Send a networkEventUpdate (responseStart) to the client
-                let msg = ResponseStartUpdateMsg {
-                    from: netevent_actor_name.clone(),
-                    type_: "networkEventUpdate".to_owned(),
-                    update_type: "responseStart".to_owned(),
-                    response: actor.response_start(),
-                };
-
-                for stream in &mut connections {
-                    let _ = stream.write_json_packet(&msg);
-                }
-                let msg = NetworkEventUpdateMsg {
-                    from: netevent_actor_name.clone(),
-                    type_: "networkEventUpdate".to_owned(),
-                    update_type: "eventTimings".to_owned(),
-                };
-                let extra = EventTimingsUpdateMsg {
-                    total_time: actor.total_time().as_millis() as u64,
-                };
-                for stream in &mut connections {
-                    let _ = stream.write_merged_json_packet(&msg, &extra);
-                }
-
-                let msg = NetworkEventUpdateMsg {
-                    from: netevent_actor_name.clone(),
-                    type_: "networkEventUpdate".to_owned(),
-                    update_type: "securityInfo".to_owned(),
-                };
-                let extra = SecurityInfoUpdateMsg {
-                    state: "insecure".to_owned(),
-                };
-                for stream in &mut connections {
-                    let _ = stream.write_merged_json_packet(&msg, &extra);
-                }
-
-                let msg = NetworkEventUpdateMsg {
-                    from: netevent_actor_name.clone(),
-                    type_: "networkEventUpdate".to_owned(),
-                    update_type: "responseContent".to_owned(),
-                };
-                for stream in &mut connections {
-                    let _ = stream.write_merged_json_packet(&msg, &actor.response_content());
-                }
-
-                let msg = NetworkEventUpdateMsg {
-                    from: netevent_actor_name.clone(),
-                    type_: "networkEventUpdate".to_owned(),
-                    update_type: "responseCookies".to_owned(),
-                };
-                for stream in &mut connections {
-                    let _ = stream.write_merged_json_packet(&msg, &actor.response_cookies());
-                }
-
-                let msg = NetworkEventUpdateMsg {
-                    from: netevent_actor_name,
-                    type_: "networkEventUpdate".to_owned(),
-                    update_type: "responseHeaders".to_owned(),
-                };
-                for stream in &mut connections {
-                    let _ = stream.write_merged_json_packet(&msg, &actor.response_headers());
-                }
-            },
-        }
+        handle_network_event(
+            Arc::clone(&self.actors),
+            console_actor_name,
+            netevent_actor_name,
+            connections,
+            network_event,
+        )
     }
 
     // Find the name of NetworkEventActor corresponding to request_id
diff --git a/components/devtools/network_handler.rs b/components/devtools/network_handler.rs
new file mode 100644
index 00000000000..a6d21820c2c
--- /dev/null
+++ b/components/devtools/network_handler.rs
@@ -0,0 +1,164 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/. */
+
+use std::net::TcpStream;
+use std::sync::{Arc, Mutex};
+
+use devtools_traits::NetworkEvent;
+use serde::Serialize;
+
+use crate::actor::ActorRegistry;
+use crate::actors::network_event::{EventActor, NetworkEventActor, ResponseStartMsg};
+use crate::protocol::JsonPacketStream;
+
+#[derive(Serialize)]
+#[serde(rename_all = "camelCase")]
+struct NetworkEventMsg {
+    from: String,
+    #[serde(rename = "type")]
+    type_: String,
+    event_actor: EventActor,
+}
+
+#[derive(Serialize)]
+#[serde(rename_all = "camelCase")]
+struct NetworkEventUpdateMsg {
+    from: String,
+    #[serde(rename = "type")]
+    type_: String,
+    update_type: String,
+}
+
+#[derive(Serialize)]
+#[serde(rename_all = "camelCase")]
+struct ResponseStartUpdateMsg {
+    from: String,
+    #[serde(rename = "type")]
+    type_: String,
+    update_type: String,
+    response: ResponseStartMsg,
+}
+
+#[derive(Serialize)]
+#[serde(rename_all = "camelCase")]
+struct EventTimingsUpdateMsg {
+    total_time: u64,
+}
+
+#[derive(Serialize)]
+struct SecurityInfoUpdateMsg {
+    state: String,
+}
+
+pub(crate) fn handle_network_event(
+    actors: Arc<Mutex<ActorRegistry>>,
+    console_actor_name: String,
+    netevent_actor_name: String,
+    mut connections: Vec<TcpStream>,
+    network_event: NetworkEvent,
+) {
+    let mut actors = actors.lock().unwrap();
+    let actor = actors.find_mut::<NetworkEventActor>(&netevent_actor_name);
+
+    match network_event {
+        NetworkEvent::HttpRequest(httprequest) => {
+            // Store the request information in the actor
+            actor.add_request(httprequest);
+
+            // Send a networkEvent message to the client
+            let msg = NetworkEventMsg {
+                from: console_actor_name,
+                type_: "networkEvent".to_owned(),
+                event_actor: actor.event_actor(),
+            };
+            for stream in &mut connections {
+                let _ = stream.write_json_packet(&msg);
+            }
+        },
+        NetworkEvent::HttpResponse(httpresponse) => {
+            // Store the response information in the actor
+            actor.add_response(httpresponse);
+
+            let msg = NetworkEventUpdateMsg {
+                from: netevent_actor_name.clone(),
+                type_: "networkEventUpdate".to_owned(),
+                update_type: "requestHeaders".to_owned(),
+            };
+            for stream in &mut connections {
+                let _ = stream.write_merged_json_packet(&msg, &actor.request_headers());
+            }
+
+            let msg = NetworkEventUpdateMsg {
+                from: netevent_actor_name.clone(),
+                type_: "networkEventUpdate".to_owned(),
+                update_type: "requestCookies".to_owned(),
+            };
+            for stream in &mut connections {
+                let _ = stream.write_merged_json_packet(&msg, &actor.request_cookies());
+            }
+
+            // Send a networkEventUpdate (responseStart) to the client
+            let msg = ResponseStartUpdateMsg {
+                from: netevent_actor_name.clone(),
+                type_: "networkEventUpdate".to_owned(),
+                update_type: "responseStart".to_owned(),
+                response: actor.response_start(),
+            };
+
+            for stream in &mut connections {
+                let _ = stream.write_json_packet(&msg);
+            }
+            let msg = NetworkEventUpdateMsg {
+                from: netevent_actor_name.clone(),
+                type_: "networkEventUpdate".to_owned(),
+                update_type: "eventTimings".to_owned(),
+            };
+            let extra = EventTimingsUpdateMsg {
+                total_time: actor.total_time().as_millis() as u64,
+            };
+            for stream in &mut connections {
+                let _ = stream.write_merged_json_packet(&msg, &extra);
+            }
+
+            let msg = NetworkEventUpdateMsg {
+                from: netevent_actor_name.clone(),
+                type_: "networkEventUpdate".to_owned(),
+                update_type: "securityInfo".to_owned(),
+            };
+            let extra = SecurityInfoUpdateMsg {
+                state: "insecure".to_owned(),
+            };
+            for stream in &mut connections {
+                let _ = stream.write_merged_json_packet(&msg, &extra);
+            }
+
+            let msg = NetworkEventUpdateMsg {
+                from: netevent_actor_name.clone(),
+                type_: "networkEventUpdate".to_owned(),
+                update_type: "responseContent".to_owned(),
+            };
+            for stream in &mut connections {
+                let _ = stream.write_merged_json_packet(&msg, &actor.response_content());
+            }
+
+            let msg = NetworkEventUpdateMsg {
+                from: netevent_actor_name.clone(),
+                type_: "networkEventUpdate".to_owned(),
+                update_type: "responseCookies".to_owned(),
+            };
+            for stream in &mut connections {
+                let _ = stream.write_merged_json_packet(&msg, &actor.response_cookies());
+            }
+
+            let msg = NetworkEventUpdateMsg {
+                from: netevent_actor_name,
+                type_: "networkEventUpdate".to_owned(),
+                update_type: "responseHeaders".to_owned(),
+            };
+            for stream in &mut connections {
+                let _ = stream.write_merged_json_packet(&msg, &actor.response_headers());
+            }
+        },
+    }
+}