Chrome 拡張機能を作ってみました (Last Tab Keeper)

タブの制御を行う、簡単な拡張機能を作ってみました。

Chromeって、最後のタブを閉じると自動的に終了するのですが、ウインドウ自体は閉じて欲しくない場合ありませんか？
その場合、先に新規タブを出しておいて、開いているWebページを閉じることになると思います。
それを少し自動化できます。

最後のタブを閉じた時のイベントを拾って、新しいタブを作ればよいと気楽に考えていたのですが、
どうもそのタイミングでは新しいタブが作れない模様。
試行錯誤して、開いているWebページが残り１タブになったら、自動的に新しいタブを作ることにしました。
人によって、合う合わないあるかと思いますが、ご興味持たれた方は是非使ってみてください。

Chrome拡張機能ギャラリーに登録してありますので、下記リンクからアクセスできます。
ご意見、ご感想などありましたら、twitterかコメント欄でメッセージ頂ければ嬉しいです。

Last Tab Keeper

※名前はちょっと微妙だったかも・・・。アイコンもデフォルトのままですみません。

終了していないスレッドを調べるクラス

ワーカースレッドが終了していないため、メインウインドウは消えてもプロセスが残ってしまう場合があります。
その場合、原因のスレッドを突き止めて終わらない原因を修正しなければいけません。
しかし、開発環境では再現できないケースなどもあると思います。その場合のデバッグ用クラスを作ってみました。

基本的に、"new Thread"を"TraceableThread.CreateThread"に置換して、メインウインドウの
FormClosedイベントあたりでTimerProcTraceを呼んであげるだけです。
そうすると、指定ミリ秒毎に終了していないスレッドがある場合、作成時のスタックトレース付きでデバッグ出力に出します。
開発環境が入っていない(入れられない)場合でも、DebugViewなどで確認できます。

VS2008で作りましたが、多分.NET2.0以降なら動くと思います。

view plainprint?

1. using System;  
2. using System.Collections.Generic;  
3. using System.Text;  
4. using System.Threading;  
5. using System.Diagnostics;  
6. using System.Reflection;  
7.   
8. namespace Diagnostics  
9. {  
10.     /// <summary>  
11.     /// スレッドの追跡を行えます。  
12.     /// 終了していないスレッドを調べるのに役立ちます。  
13.     /// </summary>  
14.     public static class TraceableThread  
15.     {  
16.         private static List<Thread> m_listThread;  
17.         private static List<StackTrace> m_listStackTrace;  
18.         private static Timer m_timerRemove;  
19.         private static Timer m_timerTrace;  
20.         private static Object m_sync;  
21.   
22.         /// <summary>  
23.         /// 静的コンストラクタ  
24.         /// </summary>  
25.         static TraceableThread()  
26.         {  
27.             // 初期化  
28.             m_listThread = new List<Thread>();  
29.             m_listStackTrace = new List<StackTrace>();  
30.             m_sync = new Object();  
31.   
32.             // スレッド終了監視タイマー  
33.             m_timerRemove = new Timer(new TimerCallback(TimerProcRemove), null, 1000, 1000);  
34.         }  
35.   
36.         /// <summary>  
37.         /// スレッドの終了を監視し、スレッドリストを更新します。  
38.         /// </summary>  
39.         private static void TimerProcRemove(Object obj)  
40.         {  
41.             lock (m_sync)  
42.             {  
43.                 List<Thread> remove = new List<Thread>();  
44.   
45.                 // 終了しているスレッドを探す  
46.                 foreach (Thread trd in m_listThread)  
47.                 {  
48.                     try  
49.                     {  
50.                         if (trd.Join(0) == true)  
51.                         {  
52.                             remove.Add(trd);  
53.                         }  
54.                     }  
55.                     catch (ThreadStateException)  
56.                     {  
57.                         // スレッドが開始されていない場合  
58.                         continue;  
59.                     }  
60.                 }  
61.   
62.                 // リストから削除する  
63.                 foreach (Thread trd in remove)  
64.                 {  
65.                     int nIndex = m_listThread.IndexOf(trd);  
66.                     m_listThread.RemoveAt(nIndex);  
67.                     m_listStackTrace.RemoveAt(nIndex);  
68.                 }  
69.             }  
70.         }  
71.   
72.         /// <summary>  
73.         /// new Thread(ParameterizedThreadStart start)の代わりに呼んでください  
74.         /// </summary>  
75.         public static Thread CreateThread(ParameterizedThreadStart start)  
76.         {  
77.             StackTrace trace = new StackTrace(true);  
78.             Thread thread;  
79.   
80.             lock (m_sync)  
81.             {  
82.                 m_listStackTrace.Add(trace);  
83.   
84.                 thread = new Thread(start);  
85.   
86.                 m_listThread.Add(thread);  
87.             }  
88.   
89.             return thread;  
90.         }  
91.   
92.         /// <summary>  
93.         /// new Thread(ThreadStart start)の代わりに呼んでください  
94.         /// </summary>  
95.         public static Thread CreateThread(ThreadStart start)  
96.         {  
97.             StackTrace trace = new StackTrace(true);  
98.             Thread thread;  
99.   
100.             lock (m_sync)  
101.             {  
102.                 m_listStackTrace.Add(trace);  
103.   
104.                 thread = new Thread(start);  
105.   
106.                 m_listThread.Add(thread);  
107.             }  
108.   
109.             return thread;  
110.         }  
111.   
112.         /// <summary>  
113.         /// new Thread(ParameterizedThreadStart start, int maxStackSize)の代わりに呼んでください  
114.         /// </summary>  
115.         public static Thread CreateThread(ParameterizedThreadStart start, int maxStackSize)  
116.         {  
117.             StackTrace trace = new StackTrace(true);  
118.             Thread thread;  
119.   
120.             lock (m_sync)  
121.             {  
122.                 m_listStackTrace.Add(trace);  
123.   
124.                 thread = new Thread(start, maxStackSize);  
125.   
126.                 m_listThread.Add(thread);  
127.             }  
128.   
129.             return thread;  
130.         }  
131.   
132.         /// <summary>  
133.         /// new Thread(ThreadStart start, int maxStackSize)の代わりに呼んでください  
134.         /// </summary>  
135.         public static Thread CreateThread(ThreadStart start, int maxStackSize)  
136.         {  
137.             StackTrace trace = new StackTrace(true);  
138.             Thread thread;  
139.   
140.             lock (m_sync)  
141.             {  
142.                 m_listStackTrace.Add(trace);  
143.   
144.                 thread = new Thread(start, maxStackSize);  
145.   
146.                 m_listThread.Add(thread);  
147.             }  
148.   
149.             return thread;  
150.         }  
151.   
152.         /// <summary>  
153.         /// スレッドの終了追跡を開始します。  
154.         /// メインウインドウのFormClosedイベントで呼び出すことで、  
155.         /// 終了していないスレッドを検出することができます。  
156.         /// </summary>  
157.         public static void TraceThreadTermination(int interval)  
158.         {  
159.             if (m_timerTrace == null)  
160.             {  
161.                 m_timerTrace = new Timer(new TimerCallback(TimerProcTrace), null, interval, interval);  
162.             }  
163.         }  
164.   
165.         /// <summary>  
166.         /// 終了していないスレッドをTraceに出力します。  
167.         /// </summary>  
168.         private static void TimerProcTrace(object obj)  
169.         {  
170.             lock (m_sync)  
171.             {  
172.                 for (int i = 0; i < m_listThread.Count; i++)  
173.                 {  
174.                     Trace.WriteLine("");  
175.                     Trace.WriteLine(DateTime.Now.ToLongTimeString());  
176.                     Trace.WriteLine("■終了していないスレッドを検出しました！");  
177.                     Trace.WriteLine("Name = " + m_listThread[i].Name + ", ManagedThreadId = " + m_listThread[i].ManagedThreadId.ToString());  
178.                     Trace.WriteLine("スレッド作成時のスタックトレースは次の通りです。");  
179.                     Trace.WriteLine(m_listStackTrace[i].ToString());  
180.                 }  
181.             }  
182.         }  
183.     }  
184. }  

using System;
using System.Collections.Generic;
using System.Text;
using System.Threading;
using System.Diagnostics;
using System.Reflection;

namespace Diagnostics
{
    /// <summary>
    /// スレッドの追跡を行えます。
    /// 終了していないスレッドを調べるのに役立ちます。
    /// </summary>
    public static class TraceableThread
    {
        private static List<Thread> m_listThread;
        private static List<StackTrace> m_listStackTrace;
        private static Timer m_timerRemove;
        private static Timer m_timerTrace;
        private static Object m_sync;

        /// <summary>
        /// 静的コンストラクタ
        /// </summary>
        static TraceableThread()
        {
            // 初期化
            m_listThread = new List<Thread>();
            m_listStackTrace = new List<StackTrace>();
            m_sync = new Object();

            // スレッド終了監視タイマー
            m_timerRemove = new Timer(new TimerCallback(TimerProcRemove), null, 1000, 1000);
        }

        /// <summary>
        /// スレッドの終了を監視し、スレッドリストを更新します。
        /// </summary>
        private static void TimerProcRemove(Object obj)
        {
            lock (m_sync)
            {
                List<Thread> remove = new List<Thread>();

                // 終了しているスレッドを探す
                foreach (Thread trd in m_listThread)
                {
                    try
                    {
                        if (trd.Join(0) == true)
                        {
                            remove.Add(trd);
                        }
                    }
                    catch (ThreadStateException)
                    {
                        // スレッドが開始されていない場合
                        continue;
                    }
                }

                // リストから削除する
                foreach (Thread trd in remove)
                {
                    int nIndex = m_listThread.IndexOf(trd);
                    m_listThread.RemoveAt(nIndex);
                    m_listStackTrace.RemoveAt(nIndex);
                }
            }
        }

        /// <summary>
        /// new Thread(ParameterizedThreadStart start)の代わりに呼んでください
        /// </summary>
        public static Thread CreateThread(ParameterizedThreadStart start)
        {
            StackTrace trace = new StackTrace(true);
            Thread thread;

            lock (m_sync)
            {
                m_listStackTrace.Add(trace);

                thread = new Thread(start);

                m_listThread.Add(thread);
            }

            return thread;
        }

        /// <summary>
        /// new Thread(ThreadStart start)の代わりに呼んでください
        /// </summary>
        public static Thread CreateThread(ThreadStart start)
        {
            StackTrace trace = new StackTrace(true);
            Thread thread;

            lock (m_sync)
            {
                m_listStackTrace.Add(trace);

                thread = new Thread(start);

                m_listThread.Add(thread);
            }

            return thread;
        }

        /// <summary>
        /// new Thread(ParameterizedThreadStart start, int maxStackSize)の代わりに呼んでください
        /// </summary>
        public static Thread CreateThread(ParameterizedThreadStart start, int maxStackSize)
        {
            StackTrace trace = new StackTrace(true);
            Thread thread;

            lock (m_sync)
            {
                m_listStackTrace.Add(trace);

                thread = new Thread(start, maxStackSize);

                m_listThread.Add(thread);
            }

            return thread;
        }

        /// <summary>
        /// new Thread(ThreadStart start, int maxStackSize)の代わりに呼んでください
        /// </summary>
        public static Thread CreateThread(ThreadStart start, int maxStackSize)
        {
            StackTrace trace = new StackTrace(true);
            Thread thread;

            lock (m_sync)
            {
                m_listStackTrace.Add(trace);

                thread = new Thread(start, maxStackSize);

                m_listThread.Add(thread);
            }

            return thread;
        }

        /// <summary>
        /// スレッドの終了追跡を開始します。
        /// メインウインドウのFormClosedイベントで呼び出すことで、
        /// 終了していないスレッドを検出することができます。
        /// </summary>
        public static void TraceThreadTermination(int interval)
        {
            if (m_timerTrace == null)
            {
                m_timerTrace = new Timer(new TimerCallback(TimerProcTrace), null, interval, interval);
            }
        }

        /// <summary>
        /// 終了していないスレッドをTraceに出力します。
        /// </summary>
        private static void TimerProcTrace(object obj)
        {
            lock (m_sync)
            {
                for (int i = 0; i < m_listThread.Count; i++)
                {
                    Trace.WriteLine("");
                    Trace.WriteLine(DateTime.Now.ToLongTimeString());
                    Trace.WriteLine("■終了していないスレッドを検出しました！");
                    Trace.WriteLine("Name = " + m_listThread[i].Name + ", ManagedThreadId = " + m_listThread[i].ManagedThreadId.ToString());
                    Trace.WriteLine("スレッド作成時のスタックトレースは次の通りです。");
                    Trace.WriteLine(m_listStackTrace[i].ToString());
                }
            }
        }
    }
}